Beispiel #1
0
    def test_wasm_local_float(self):
        with gdb_rsp.LaunchDebugStub(COMMAND) as connection:
            self.RunToWasm(connection)
            module_load_addr = gdb_rsp.GetLoadedModuleAddress(connection)

            reply = connection.RspRequest('qWasmLocal:0;0')
            value = struct.unpack('f', gdb_rsp.DecodeHex(reply))[0]
            self.assertEqual(test_float.ARG_0, value)

            reply = connection.RspRequest('qWasmLocal:0;1')
            value = struct.unpack('f', gdb_rsp.DecodeHex(reply))[0]
            self.assertEqual(test_float.ARG_1, value)

            # invalid local
            reply = connection.RspRequest('qWasmLocal:0;9')
            self.assertEqual("E03", reply)
Beispiel #2
0
    def test_reading_and_writing_memory(self):
        with gdb_rsp.LaunchDebugStub(COMMAND) as connection:
            module_load_addr = gdb_rsp.GetLoadedModuleAddress(connection)
            breakpoint_addr = module_load_addr + test_memory.FUNC0_START_ADDR
            self.RunToWasm(connection, breakpoint_addr)

            self.CheckReadMemoryAtInvalidAddr(connection)

            # Check reading code memory space.
            expected_data = b'\0asm'
            result = gdb_rsp.ReadCodeMemory(connection, module_load_addr,
                                            len(expected_data))
            self.assertEqual(result, expected_data)

            # Check reading instance memory at a valid range.
            module_id = module_load_addr >> 32
            reply = connection.RspRequest('qWasmMem:%d;%x;%x' %
                                          (module_id, 32, 4))
            value = struct.unpack('I', gdb_rsp.DecodeHex(reply))[0]
            self.assertEquals(int(value), 0)

            # Check reading instance memory at an invalid range.
            reply = connection.RspRequest('qWasmMem:%d;%x;%x' %
                                          (module_id, 0xf0000000, 4))
            self.assertEqual(reply, 'E03')
Beispiel #3
0
    def test_wasm_stack_value(self):
        with gdb_rsp.LaunchDebugStub(COMMAND) as connection:
            module_load_addr = gdb_rsp.GetLoadedModuleAddress(connection)
            breakpoint_addr = module_load_addr + test_basic.BREAK_ADDRESS_2

            reply = connection.RspRequest('Z0,%x,1' % breakpoint_addr)
            self.assertEqual("OK", reply)
            reply = connection.RspRequest('c')
            gdb_rsp.AssertReplySignal(reply, gdb_rsp.SIGTRAP)

            reply = connection.RspRequest('qWasmStackValue:0;0')
            value = struct.unpack('I', gdb_rsp.DecodeHex(reply))[0]
            self.assertEqual(test_basic.ARG_0, value)

            reply = connection.RspRequest('qWasmStackValue:0;1')
            value = struct.unpack('I', gdb_rsp.DecodeHex(reply))[0]
            self.assertEqual(test_basic.ARG_1, value)

            # invalid index
            reply = connection.RspRequest('qWasmStackValue:0;2')
            self.assertEqual("E03", reply)
Beispiel #4
0
    def test_wasm_global(self):
        with gdb_rsp.LaunchDebugStub(COMMAND) as connection:
            module_load_addr = gdb_rsp.GetLoadedModuleAddress(connection)
            breakpoint_addr = module_load_addr + test_memory.FUNC0_START_ADDR
            self.RunToWasm(connection, breakpoint_addr)

            # Check reading valid global.
            reply = connection.RspRequest('qWasmGlobal:0;0')
            value = struct.unpack('I', gdb_rsp.DecodeHex(reply))[0]
            self.assertEqual(0, value)

            # Check reading invalid global.
            reply = connection.RspRequest('qWasmGlobal:0;9')
            self.assertEqual("E03", reply)
Beispiel #5
0
    def test_reading_and_writing_data_section(self):
        with gdb_rsp.LaunchDebugStub(COMMAND) as connection:
            module_load_addr = gdb_rsp.GetLoadedModuleAddress(connection)
            breakpoint_addr = module_load_addr + test_memory.FUNC0_START_ADDR
            self.RunToWasm(connection, breakpoint_addr)

            # Check reading instance memory at a valid range.
            module_id = module_load_addr >> 32
            reply = connection.RspRequest(
                'qWasmData:%d;%x;%x' %
                (module_id, test_memory.DATA_OFFSET, test_memory.DATA_SIZE))
            value = struct.unpack('I', gdb_rsp.DecodeHex(reply))[0]
            self.assertEquals(int(value), test_memory.DATA_CONTENT)

            # Check reading instance memory at an invalid range.
            reply = connection.RspRequest('qWasmData:%d;%x;%x' %
                                          (module_id, 0xf0000000, 4))
            self.assertEqual(reply, 'E03')