Exemple #1
0
    def _createState(self):
        state = State()

        expected_mem_state_data = []
        mem_block_size = RandomUtils.random32(0x8, 0x20) * 16
        self._mMemBlockStartAddr = self.genVA(Size=mem_block_size,
                                              Align=16,
                                              Type="D")
        self._mMemBlockEndAddr = self._mMemBlockStartAddr + mem_block_size - 1
        cur_addr = self._mMemBlockStartAddr
        while cur_addr <= self._mMemBlockEndAddr:
            if self.getGlobalState("AppRegisterWidth") == 32:
                mem_val = RandomUtils.random32()
                state.addMemoryStateElement(cur_addr, 4, mem_val)
                expected_mem_state_data.append((cur_addr, mem_val))
                cur_addr += 4
            else:
                mem_val = RandomUtils.random64()
                state.addMemoryStateElement(cur_addr, 8, mem_val)
                expected_mem_state_data.append((cur_addr, mem_val))
                cur_addr += 8

        self._mExpectedStateData[
            EStateElementType.Memory] = expected_mem_state_data

        return state
Exemple #2
0
    def createState(self, gprIndices):
        state = State()

        for i in range(1, 4):
            # Get a random 8-byte virtual address for data
            mem_start_addr = self.genVA(Size=8, Align=8, Type="D")

            # Specify the value of i for the memory location
            state.addMemoryStateElement(mem_start_addr, 8, i)

            gpr_index = gprIndices[i]
            gpr_name = "x%d" % gpr_index

            # Specify the memory address as the value of the GPR
            state.addRegisterStateElement(gpr_name, [mem_start_addr])

        return state
Exemple #3
0
    def generate(self, **kargs):
        state = State()
        state.setDuplicateMode(EStateElementDuplicateMode.Replace)

        mem_start_addr = (RandomUtils.random64(0, 0xFFFFFFFFFFFF) >> 3) << 3
        mem_val = RandomUtils.random64()
        state.addMemoryStateElement(mem_start_addr, 8, mem_val)

        mem_values = []
        for _ in range(RandomUtils.random32(1, 64)):
            mem_values.append(RandomUtils.random32(0, 0xFF))

        mem_start_addr = RandomUtils.random64(0, 0xFFFFFFFFFFFF)
        state.addMemoryStateElementsAsBytes(mem_start_addr, mem_values)

        gpr_name = "x%d" % RandomUtils.random32(0, 31)
        state.addRegisterStateElement(gpr_name, (RandomUtils.random64(),))
        fp_reg_name = "D%d" % RandomUtils.random32(0, 31)
        state.addRegisterStateElement(fp_reg_name, (RandomUtils.random64(),))

        state.addSystemRegisterStateElementByField("sstatus", "FS", 0x3)

        state.addVmContextStateElement("mstatus", "MPRV", 0x1)

        state.addPcStateElement(RandomUtils.random64(0, 0xFFFFFFFFFFFF))

        # Test creating duplicate StateElements
        state.addVmContextStateElement("mstatus", "MPRV", 0x0)
        state.setDuplicateMode(EStateElementDuplicateMode.Ignore)
        state.addRegisterStateElement("sstatus", (RandomUtils.random64(),))

        # Test merging two StateElements
        mem_start_addr = (RandomUtils.random64(0, 0xFFFFFFFFFFFF) >> 3) << 3
        mem_val = RandomUtils.random32()
        state.addMemoryStateElement(mem_start_addr, 4, mem_val)

        mem_start_addr += 4
        mem_values = []
        for _ in range(4):
            mem_values.append(RandomUtils.random32(0, 0xFF))

        state.addMemoryStateElementsAsBytes(mem_start_addr, mem_values)