def _createState(self):
state = State()
# The priorities are set in such a way as to enable floating point before loading the
# floating point registers
expected_sys_reg_state_data = []
sys_reg_name = 'misa'
(sys_reg_val, valid) = self.readRegister(sys_reg_name)
state_transition_test_utils.assertValidRegisterValue(
self, sys_reg_name, valid)
sys_reg_val |= 0x0000028
state.addRegisterStateElement(sys_reg_name, (sys_reg_val, ),
aPriority=1)
expected_sys_reg_state_data.append((sys_reg_name, sys_reg_val))
self._mExpectedStateData[
EStateElementType.SystemRegister] = expected_sys_reg_state_data
self._mExpectedStateData[
EStateElementType.
FloatingPointRegister] = state_transition_test_utils.addRandomFloatingPointRegisterStateElements(
self,
state,
RandomUtils.random32(0, 10),
aPriorityMin=2,
aPriorityMax=4)
return state
def _createVectorRegisterStateElements(self, aState):
expected_vec_reg_state_data = {}
vec_reg_count = RandomUtils.random32(0, 10)
vec_reg_indices = self.sample(range(0, 32), vec_reg_count)
max_reg_val_count = self.getLimitValue('MaxPhysicalVectorLen') // 64
for vec_reg_index in vec_reg_indices:
vec_reg_values = []
state_elem_reg_val_count = RandomUtils.random32(
1, max_reg_val_count)
for val_index in range(state_elem_reg_val_count):
vec_reg_values.append(RandomUtils.random64())
vec_reg_name = 'v%d' % vec_reg_index
self.randomInitializeRegister(vec_reg_name)
aState.addRegisterStateElement(vec_reg_name, vec_reg_values)
for val_index in range(state_elem_reg_val_count,
max_reg_val_count):
field_name = '%s_%d' % (vec_reg_name, val_index)
(field_val, valid) = self.readRegister(vec_reg_name,
field=field_name)
state_transition_test_utils.assertValidRegisterValue(
self, vec_reg_name, valid)
vec_reg_values.append(field_val)
expected_vec_reg_state_data[vec_reg_name] = vec_reg_values
return expected_vec_reg_state_data
def _createStateC(self):
state = State()
self._mExpectedStateData = {}
expected_sys_reg_state_data = []
fcsr_name = 'fcsr'
state.addSystemRegisterStateElementByField(fcsr_name, 'FRM', 1)
(fcsr_val, valid) = self.readRegister(fcsr_name)
state_transition_test_utils.assertValidRegisterValue(
self, fcsr_name, valid)
fcsr_val = state_transition_test_utils.combineRegisterValueWithFieldValue(
self, fcsr_name, fcsr_val, 'FRM', 1)
# TODO(Noah): Enable verification of setting the fcsr register when the readRegister()
# method reads the correct value for fcsr. Currently, the top 58 bits are being initialized
# to a non-zero value by Force, which is not legal.
#expected_sys_reg_state_data.append((fcsr_name, fcsr_val))
expected_fp_reg_state_data = []
for fp_reg_index in range(0, 32):
fp_reg_val = RandomUtils.random64(0, 0x3FFFFFFFFFFFFFFF)
state.addRegisterStateElement(('D%d' % fp_reg_index),
(fp_reg_val, ))
self._mExpectedStateData[
EStateElementType.
FloatingPointRegister] = expected_fp_reg_state_data
sstatus_name = 'sstatus'
fs_val = RandomUtils.random32(1, 3)
state.addSystemRegisterStateElementByField(sstatus_name, 'FS', fs_val)
(sstatus_val, valid) = self.readRegister(sstatus_name)
state_transition_test_utils.assertValidRegisterValue(
self, sstatus_name, valid)
sstatus_val = state_transition_test_utils.combineRegisterValueWithFieldValue(
self, sstatus_name, sstatus_val, 'FS', fs_val)
# Adjust expected value of SD bit according to architecture rules
(xs_val, valid) = self.readRegister(sstatus_name, field='XS')
state_transition_test_utils.assertValidRegisterValue(
self, sstatus_name, valid)
(vs_val, valid) = self.readRegister(sstatus_name, field='VS')
state_transition_test_utils.assertValidRegisterValue(
self, sstatus_name, valid)
if (fs_val == 3) or (xs_val == 3) or (vs_val == 3):
sstatus_val = state_transition_test_utils.combineRegisterValueWithFieldValue(
self, sstatus_name, sstatus_val, 'SD', 1)
else:
sstatus_val = state_transition_test_utils.combineRegisterValueWithFieldValue(
self, sstatus_name, sstatus_val, 'SD', 0)
expected_sys_reg_state_data.append((sstatus_name, sstatus_val))
self._mExpectedStateData[
EStateElementType.SystemRegister] = expected_sys_reg_state_data
return state
def _createSystemRegisterStateElements(self, aState):
sys_reg_name = 'mstatus'
aState.addSystemRegisterStateElementByField(sys_reg_name, 'MIE', 0x0)
aState.addSystemRegisterStateElementByField(sys_reg_name, 'MPRV', 0x1)
self.randomInitializeRegister(sys_reg_name)
(sys_reg_val, valid) = self.readRegister(sys_reg_name)
state_transition_test_utils.assertValidRegisterValue(
self, sys_reg_name, valid)
sys_reg_val = state_transition_test_utils.combineRegisterValueWithFieldValue(
self, sys_reg_name, sys_reg_val, 'MIE', 0x0)
sys_reg_val = state_transition_test_utils.combineRegisterValueWithFieldValue(
self, sys_reg_name, sys_reg_val, 'MPRV', 0x1)
return {sys_reg_name: sys_reg_val}
def _createState(self):
state = State()
expected_sys_reg_state_data = []
mcause_name = 'mcause'
exception_code_var_val = RandomUtils.random32(0, 9)
state.addSystemRegisterStateElementByField(mcause_name,
'EXCEPTION CODE_VAR',
exception_code_var_val)
self.randomInitializeRegister(mcause_name)
(mcause_val, valid) = self.readRegister(mcause_name)
state_transition_test_utils.assertValidRegisterValue(
self, mcause_name, valid)
mcause_val = state_transition_test_utils.combineRegisterValueWithFieldValue(
self, mcause_name, mcause_val, 'EXCEPTION CODE_VAR',
exception_code_var_val)
expected_sys_reg_state_data.append((mcause_name, mcause_val))
mtvec_name = 'mtvec'
mode_val = RandomUtils.random32(0, 1)
state.addSystemRegisterStateElementByField('mtvec', 'MODE', mode_val)
self.randomInitializeRegister(mtvec_name)
(mtvec_val, valid) = self.readRegister(mtvec_name)
state_transition_test_utils.assertValidRegisterValue(
self, mtvec_name, valid)
mtvec_val = state_transition_test_utils.combineRegisterValueWithFieldValue(
self, mtvec_name, mtvec_val, 'MODE', mode_val)
expected_sys_reg_state_data.append((mtvec_name, mtvec_val))
self._mExpectedStateData[
EStateElementType.SystemRegister] = expected_sys_reg_state_data
self._mExpectedStateData[
EStateElementType.
GPR] = state_transition_test_utils.addRandomGprStateElements(
self, state, RandomUtils.random32(0, 5))
self._mExpectedStateData[
EStateElementType.
PC] = state_transition_test_utils.addRandomPcStateElement(
self, state)
return state
def generate(self, **kargs):
# Disable floating point, so the StateTransition can enable it
sys_reg_name = 'misa'
(sys_reg_val, valid) = self.readRegister(sys_reg_name)
state_transition_test_utils.assertValidRegisterValue(
self, sys_reg_name, valid)
load_gpr64_seq = LoadGPR64(self.genThread)
rand_gpr_index = self.getRandomGPR(exclude='0')
load_gpr64_seq.load(rand_gpr_index, 0x0000028)
self.genInstruction(
'CSRRC#register#RISCV', {
'rd': 0,
'rs1': rand_gpr_index,
'csr': self.getRegisterIndex(sys_reg_name)
})
state = self._createState()
StateTransition.transitionToState(state,
EStateTransitionOrderMode.ByPriority)
state_transition_test_utils.verifyState(self, self._mExpectedStateData)
def _createState(self):
state = State()
expected_sys_reg_state_data = []
mscratch_val = RandomUtils.random64()
state.addRegisterStateElement('mscratch', (mscratch_val, ))
expected_sys_reg_state_data.append(('mscratch', mscratch_val))
scause_name = 'scause'
exception_code_var_val = RandomUtils.random32(0, 9)
state.addSystemRegisterStateElementByField(scause_name,
'EXCEPTION CODE_VAR',
exception_code_var_val)
self.randomInitializeRegister(scause_name)
(scause_val, valid) = self.readRegister(scause_name)
state_transition_test_utils.assertValidRegisterValue(
self, scause_name, valid)
scause_val = state_transition_test_utils.combineRegisterValueWithFieldValue(
self, scause_name, scause_val, 'EXCEPTION CODE_VAR',
exception_code_var_val)
expected_sys_reg_state_data.append((scause_name, scause_val))
stvec_name = 'stvec'
mode_val = RandomUtils.random32(0, 1)
state.addSystemRegisterStateElementByField(stvec_name, 'MODE',
mode_val)
self.randomInitializeRegister(stvec_name)
(stvec_val, valid) = self.readRegister(stvec_name)
state_transition_test_utils.assertValidRegisterValue(
self, stvec_name, valid)
stvec_val = state_transition_test_utils.combineRegisterValueWithFieldValue(
self, stvec_name, stvec_val, 'MODE', mode_val)
expected_sys_reg_state_data.append((stvec_name, stvec_val))
self._mExpectedStateData[
EStateElementType.SystemRegister] = expected_sys_reg_state_data
return state
def _createFloatingPointRegisterStateElements(self, aState):
expected_fp_reg_state_data = {}
fp_reg_count = RandomUtils.random32(0, 10)
fp_reg_indices = self.sample(range(0, 32), fp_reg_count)
for fp_reg_index in fp_reg_indices:
fp_reg_name = 'S%d' % fp_reg_index
fp_reg_val = RandomUtils.random32()
aState.addRegisterStateElement(fp_reg_name, (fp_reg_val, ))
containing_fp_reg_name = 'D%d' % fp_reg_index
self.randomInitializeRegister(containing_fp_reg_name)
(orig_fp_reg_val,
valid) = self.readRegister(containing_fp_reg_name)
state_transition_test_utils.assertValidRegisterValue(
self, containing_fp_reg_name, valid)
combined_fp_reg_val = (orig_fp_reg_val &
(0xFFFFFFFF << 32)) | fp_reg_val
expected_fp_reg_state_data[
containing_fp_reg_name] = combined_fp_reg_val
return expected_fp_reg_state_data