| #!/usr/bin/env python3 |
| # Copyright 2021 The Chromium Authors |
| # Use of this source code is governed by a BSD-style license that can be |
| # found in the LICENSE file. |
| """Tests for create_unwind_table.py. |
| |
| This test suite contains tests for the custom unwind table creation for 32-bit |
| arm builds. |
| """ |
| |
| import io |
| import struct |
| |
| import unittest |
| import unittest.mock |
| import re |
| |
| from create_unwind_table import ( |
| AddressCfi, AddressUnwind, FilterToNonTombstoneCfi, FunctionCfi, |
| FunctionUnwind, EncodeAddressUnwind, EncodeAddressUnwinds, |
| EncodedAddressUnwind, EncodeAsBytes, EncodeFunctionOffsetTable, |
| EncodedFunctionUnwind, EncodeFunctionUnwinds, EncodeStackPointerUpdate, |
| EncodePop, EncodePageTableAndFunctionTable, EncodeUnwindInfo, |
| EncodeUnwindInstructionTable, GenerateUnwinds, GenerateUnwindTables, |
| NullParser, ParseAddressCfi, PushOrSubSpParser, ReadFunctionCfi, |
| REFUSE_TO_UNWIND, StoreSpParser, TRIVIAL_UNWIND, Uleb128Encode, |
| UnwindInstructionsParser, UnwindType, VPushParser) |
| |
| |
| class _TestReadFunctionCfi(unittest.TestCase): |
| def testFilterTombstone(self): |
| input_lines = [ |
| 'file name', |
| 'STACK CFI INIT 0 ', |
| 'STACK CFI 100 ', |
| 'STACK CFI INIT 1 ', |
| 'STACK CFI 200 ', |
| ] |
| |
| f = io.StringIO(''.join(line + '\n' for line in input_lines)) |
| |
| self.assertEqual([ |
| 'STACK CFI INIT 1 \n', |
| 'STACK CFI 200 \n', |
| ], list(FilterToNonTombstoneCfi(f))) |
| |
| def testReadFunctionCfiTombstoneFiltered(self): |
| input_lines = [ |
| 'STACK CFI INIT 0 50 .cfa: sp 0 + .ra: lr', # Tombstone function. |
| 'STACK CFI 2 .cfa: sp 24 + .ra: .cfa - 4 + ^ r4: .cfa - 16 + ^ ' |
| 'r5: .cfa - 12 + ^ r7: .cfa - 8 + ^', |
| 'STACK CFI INIT 15b6490 4 .cfa: sp 0 + .ra: lr', |
| ] |
| |
| f = io.StringIO(''.join(line + '\n' for line in input_lines)) |
| |
| self.assertEqual( |
| [FunctionCfi(4, (AddressCfi(0x15b6490, '.cfa: sp 0 + .ra: lr'), ))], |
| list(ReadFunctionCfi(f))) |
| |
| def testReadFunctionCfiSingleFunction(self): |
| input_lines = [ |
| 'STACK CFI INIT 15b6490 4 .cfa: sp 0 + .ra: lr', |
| 'STACK CFI 2 .cfa: sp 24 + .ra: .cfa - 4 + ^ r4: .cfa - 16 + ^ ' |
| 'r5: .cfa - 12 + ^ r7: .cfa - 8 + ^', |
| ] |
| |
| f = io.StringIO(''.join(line + '\n' for line in input_lines)) |
| |
| self.assertEqual([ |
| FunctionCfi(4, ( |
| AddressCfi(0x15b6490, '.cfa: sp 0 + .ra: lr'), |
| AddressCfi( |
| 0x2, '.cfa: sp 24 + .ra: .cfa - 4 + ^ r4: .cfa - 16 + ^ ' |
| 'r5: .cfa - 12 + ^ r7: .cfa - 8 + ^'), |
| )) |
| ], list(ReadFunctionCfi(f))) |
| |
| def testReadFunctionCfiMultipleFunctions(self): |
| input_lines = [ |
| 'STACK CFI INIT 15b6490 4 .cfa: sp 0 + .ra: lr', |
| 'STACK CFI 2 .cfa: sp 24 + .ra: .cfa - 4 + ^ r4: .cfa - 16 + ^ ' |
| 'r5: .cfa - 12 + ^ r7: .cfa - 8 + ^', |
| 'STACK CFI INIT 15b655a 26 .cfa: sp 0 + .ra: lr', |
| 'STACK CFI 15b655c .cfa: sp 8 + .ra: .cfa - 4 + ^ r4: .cfa - 8 + ^', |
| ] |
| |
| f = io.StringIO(''.join(line + '\n' for line in input_lines)) |
| |
| self.assertEqual([ |
| FunctionCfi(0x4, ( |
| AddressCfi(0x15b6490, '.cfa: sp 0 + .ra: lr'), |
| AddressCfi( |
| 0x2, '.cfa: sp 24 + .ra: .cfa - 4 + ^ r4: .cfa - 16 + ^ ' |
| 'r5: .cfa - 12 + ^ r7: .cfa - 8 + ^'), |
| )), |
| FunctionCfi(0x26, ( |
| AddressCfi(0x15b655a, '.cfa: sp 0 + .ra: lr'), |
| AddressCfi(0x15b655c, |
| '.cfa: sp 8 + .ra: .cfa - 4 + ^ r4: .cfa - 8 + ^'), |
| )), |
| ], list(ReadFunctionCfi(f))) |
| |
| |
| class _TestEncodeAsBytes(unittest.TestCase): |
| def testOutOfBounds(self): |
| self.assertRaises(ValueError, lambda: EncodeAsBytes(1024)) |
| self.assertRaises(ValueError, lambda: EncodeAsBytes(256)) |
| self.assertRaises(ValueError, lambda: EncodeAsBytes(-1)) |
| |
| def testEncode(self): |
| self.assertEqual(bytes([0]), EncodeAsBytes(0)) |
| self.assertEqual(bytes([255]), EncodeAsBytes(255)) |
| self.assertEqual(bytes([0, 1]), EncodeAsBytes(0, 1)) |
| |
| |
| class _TestUleb128Encode(unittest.TestCase): |
| def testNegativeValue(self): |
| self.assertRaises(ValueError, lambda: Uleb128Encode(-1)) |
| |
| def testSingleByte(self): |
| self.assertEqual(bytes([0]), Uleb128Encode(0)) |
| self.assertEqual(bytes([1]), Uleb128Encode(1)) |
| self.assertEqual(bytes([127]), Uleb128Encode(127)) |
| |
| def testMultiBytes(self): |
| self.assertEqual(bytes([0b10000000, 0b1]), Uleb128Encode(128)) |
| self.assertEqual(bytes([0b10000000, 0b10000000, 0b1]), |
| Uleb128Encode(128**2)) |
| |
| |
| class _TestEncodeStackPointerUpdate(unittest.TestCase): |
| def testSingleByte(self): |
| self.assertEqual(bytes([0b00000000 | 0]), EncodeStackPointerUpdate(4)) |
| self.assertEqual(bytes([0b01000000 | 0]), EncodeStackPointerUpdate(-4)) |
| |
| self.assertEqual(bytes([0b00000000 | 0b00111111]), |
| EncodeStackPointerUpdate(0x100)) |
| self.assertEqual(bytes([0b01000000 | 0b00111111]), |
| EncodeStackPointerUpdate(-0x100)) |
| |
| self.assertEqual(bytes([0b00000000 | 3]), EncodeStackPointerUpdate(16)) |
| self.assertEqual(bytes([0b01000000 | 3]), EncodeStackPointerUpdate(-16)) |
| |
| self.assertEqual(bytes([0b00111111]), EncodeStackPointerUpdate(0x100)) |
| |
| # 10110010 uleb128 |
| # vsp = vsp + 0x204 + (uleb128 << 2) |
| self.assertEqual(bytes([0b10110010, 0b00000000]), |
| EncodeStackPointerUpdate(0x204)) |
| self.assertEqual(bytes([0b10110010, 0b00000001]), |
| EncodeStackPointerUpdate(0x208)) |
| |
| # For vsp increments of 0x104-0x200, use 00xxxxxx twice. |
| self.assertEqual(bytes([0b00111111, 0b00000000]), |
| EncodeStackPointerUpdate(0x104)) |
| self.assertEqual(bytes([0b00111111, 0b00111111]), |
| EncodeStackPointerUpdate(0x200)) |
| self.assertEqual(bytes([0b01111111, 0b01111111]), |
| EncodeStackPointerUpdate(-0x200)) |
| |
| # Not multiple of 4. |
| self.assertRaises(AssertionError, lambda: EncodeStackPointerUpdate(101)) |
| # offset=0 is meaningless. |
| self.assertRaises(AssertionError, lambda: EncodeStackPointerUpdate(0)) |
| |
| |
| class _TestEncodePop(unittest.TestCase): |
| def testSingleRegister(self): |
| # Should reject registers outside r4 ~ r15 range. |
| for r in 0, 1, 2, 3, 16: |
| self.assertRaises(AssertionError, lambda: EncodePop([r])) |
| # Should use |
| # 1000iiii iiiiiiii |
| # Pop up to 12 integer registers under masks {r15-r12}, {r11-r4}. |
| self.assertEqual(bytes([0b10000000, 0b00000001]), EncodePop([4])) |
| self.assertEqual(bytes([0b10000000, 0b00001000]), EncodePop([7])) |
| self.assertEqual(bytes([0b10000100, 0b00000000]), EncodePop([14])) |
| self.assertEqual(bytes([0b10001000, 0b00000000]), EncodePop([15])) |
| |
| def testContinuousRegisters(self): |
| # 10101nnn |
| # Pop r4-r[4+nnn], r14. |
| self.assertEqual(bytes([0b10101000]), EncodePop([4, 14])) |
| self.assertEqual(bytes([0b10101001]), EncodePop([4, 5, 14])) |
| self.assertEqual(bytes([0b10101111]), |
| EncodePop([4, 5, 6, 7, 8, 9, 10, 11, 14])) |
| |
| def testDiscontinuousRegisters(self): |
| # 1000iiii iiiiiiii |
| # Pop up to 12 integer registers under masks {r15-r12}, {r11-r4}. |
| self.assertEqual(bytes([0b10001000, 0b00000001]), EncodePop([4, 15])) |
| self.assertEqual(bytes([0b10000100, 0b00011000]), EncodePop([7, 8, 14])) |
| self.assertEqual(bytes([0b10000111, 0b11111111]), |
| EncodePop([4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14])) |
| self.assertEqual(bytes([0b10000100, 0b10111111]), |
| EncodePop([4, 5, 6, 7, 8, 9, 11, 14])) |
| |
| |
| class _TestEncodeAddressUnwind(unittest.TestCase): |
| def testReturnToLr(self): |
| self.assertEqual( |
| bytes([0b10110000]), |
| EncodeAddressUnwind( |
| AddressUnwind(address_offset=0, |
| unwind_type=UnwindType.RETURN_TO_LR, |
| sp_offset=0, |
| registers=tuple()))) |
| |
| def testNoAction(self): |
| self.assertEqual( |
| bytes([]), |
| EncodeAddressUnwind( |
| AddressUnwind(address_offset=0, |
| unwind_type=UnwindType.NO_ACTION, |
| sp_offset=0, |
| registers=tuple()))) |
| |
| def testUpdateSpAndOrPopRegisters(self): |
| self.assertEqual( |
| bytes([0b0, 0b10101000]), |
| EncodeAddressUnwind( |
| AddressUnwind(address_offset=0, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=0x4, |
| registers=(4, 14)))) |
| |
| self.assertEqual( |
| bytes([0b0]), |
| EncodeAddressUnwind( |
| AddressUnwind(address_offset=0, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=0x4, |
| registers=tuple()))) |
| |
| self.assertEqual( |
| bytes([0b10101000]), |
| EncodeAddressUnwind( |
| AddressUnwind(address_offset=0, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=0, |
| registers=(4, 14)))) |
| |
| def testRestoreSpFromRegisters(self): |
| self.assertEqual( |
| bytes([0b10010100, 0b0]), |
| EncodeAddressUnwind( |
| AddressUnwind(address_offset=0, |
| unwind_type=UnwindType.RESTORE_SP_FROM_REGISTER, |
| sp_offset=0x4, |
| registers=(4, )))) |
| |
| self.assertEqual( |
| bytes([0b10010100]), |
| EncodeAddressUnwind( |
| AddressUnwind(address_offset=0, |
| unwind_type=UnwindType.RESTORE_SP_FROM_REGISTER, |
| sp_offset=0, |
| registers=(4, )))) |
| |
| self.assertRaises( |
| AssertionError, lambda: EncodeAddressUnwind( |
| AddressUnwind(address_offset=0, |
| unwind_type=UnwindType.RESTORE_SP_FROM_REGISTER, |
| sp_offset=0x4, |
| registers=tuple()))) |
| |
| |
| class _TestEncodeAddressUnwinds(unittest.TestCase): |
| def testEncodeOrder(self): |
| address_unwind1 = AddressUnwind(address_offset=0, |
| unwind_type=UnwindType.RETURN_TO_LR, |
| sp_offset=0, |
| registers=tuple()) |
| address_unwind2 = AddressUnwind( |
| address_offset=4, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=0, |
| registers=(4, 14)) |
| |
| def MockEncodeAddressUnwind(address_unwind): |
| return { |
| address_unwind1: bytes([1]), |
| address_unwind2: bytes([2]), |
| }[address_unwind] |
| |
| with unittest.mock.patch("create_unwind_table.EncodeAddressUnwind", |
| side_effect=MockEncodeAddressUnwind): |
| encoded_unwinds = EncodeAddressUnwinds((address_unwind1, address_unwind2)) |
| self.assertEqual(( |
| EncodedAddressUnwind(4, |
| bytes([2]) + bytes([1])), |
| EncodedAddressUnwind(0, bytes([1])), |
| ), encoded_unwinds) |
| |
| |
| PAGE_SIZE = 1 << 17 |
| |
| |
| class _TestEncodeFunctionUnwinds(unittest.TestCase): |
| @unittest.mock.patch('create_unwind_table.EncodeAddressUnwinds') |
| def testEncodeOrder(self, MockEncodeAddressUnwinds): |
| MockEncodeAddressUnwinds.return_value = EncodedAddressUnwind(0, b'\x00') |
| |
| self.assertEqual([ |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=0, |
| address_unwinds=EncodedAddressUnwind(0, b'\x00')), |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=100 >> 1, |
| address_unwinds=EncodedAddressUnwind(0, b'\x00')), |
| ], |
| list( |
| EncodeFunctionUnwinds([ |
| FunctionUnwind(address=100, |
| size=PAGE_SIZE - 100, |
| address_unwinds=()), |
| FunctionUnwind( |
| address=0, size=100, address_unwinds=()), |
| ], |
| text_section_start_address=0))) |
| |
| @unittest.mock.patch('create_unwind_table.EncodeAddressUnwinds') |
| def testFillingGaps(self, MockEncodeAddressUnwinds): |
| MockEncodeAddressUnwinds.return_value = EncodedAddressUnwind(0, b'\x00') |
| |
| self.assertEqual([ |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=0, |
| address_unwinds=EncodedAddressUnwind(0, b'\x00')), |
| EncodedFunctionUnwind( |
| page_number=0, page_offset=50 >> 1, address_unwinds=TRIVIAL_UNWIND), |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=100 >> 1, |
| address_unwinds=EncodedAddressUnwind(0, b'\x00')), |
| ], |
| list( |
| EncodeFunctionUnwinds([ |
| FunctionUnwind( |
| address=0, size=50, address_unwinds=()), |
| FunctionUnwind(address=100, |
| size=PAGE_SIZE - 100, |
| address_unwinds=()), |
| ], |
| text_section_start_address=0))) |
| |
| @unittest.mock.patch('create_unwind_table.EncodeAddressUnwinds') |
| def testFillingLastPage(self, MockEncodeAddressUnwinds): |
| MockEncodeAddressUnwinds.return_value = EncodedAddressUnwind(0, b'\x00') |
| |
| self.assertEqual( |
| [ |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=0, |
| address_unwinds=EncodedAddressUnwind( |
| 0, b'\x00')), |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=100 >> 1, |
| address_unwinds=EncodedAddressUnwind( |
| 0, b'\x00')), |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=200 >> 1, |
| address_unwinds=REFUSE_TO_UNWIND), |
| ], |
| list( |
| EncodeFunctionUnwinds([ |
| FunctionUnwind(address=1100, size=100, address_unwinds=()), |
| FunctionUnwind(address=1200, size=100, address_unwinds=()), |
| ], |
| text_section_start_address=1100))) |
| |
| @unittest.mock.patch('create_unwind_table.EncodeAddressUnwinds') |
| def testFillingFirstPage(self, MockEncodeAddressUnwinds): |
| MockEncodeAddressUnwinds.return_value = EncodedAddressUnwind(0, b'\x00') |
| |
| self.assertEqual( |
| [ |
| EncodedFunctionUnwind( |
| page_number=0, page_offset=0, address_unwinds=REFUSE_TO_UNWIND), |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=100 >> 1, |
| address_unwinds=EncodedAddressUnwind( |
| 0, b'\x00')), |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=200 >> 1, |
| address_unwinds=EncodedAddressUnwind( |
| 0, b'\x00')), |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=300 >> 1, |
| address_unwinds=REFUSE_TO_UNWIND), |
| ], |
| list( |
| EncodeFunctionUnwinds([ |
| FunctionUnwind(address=1100, size=100, address_unwinds=()), |
| FunctionUnwind(address=1200, size=100, address_unwinds=()), |
| ], |
| text_section_start_address=1000))) |
| |
| @unittest.mock.patch('create_unwind_table.EncodeAddressUnwinds') |
| def testOverlappedFunctions(self, _): |
| self.assertRaises( |
| # Eval generator with `list`. Otherwise the code will not execute. |
| AssertionError, |
| lambda: list( |
| EncodeFunctionUnwinds([ |
| FunctionUnwind(address=0, size=100, address_unwinds=()), |
| FunctionUnwind(address=50, size=100, address_unwinds=()), |
| ], |
| text_section_start_address=0))) |
| |
| |
| class _TestNullParser(unittest.TestCase): |
| def testCfaChange(self): |
| parser = NullParser() |
| match = parser.GetBreakpadInstructionsRegex().search('.cfa: sp 0 + .ra: lr') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=0, |
| cfa_sp_offset=0, |
| match=match) |
| |
| self.assertEqual(0, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=0, |
| unwind_type=UnwindType.RETURN_TO_LR, |
| sp_offset=0, |
| registers=()), address_unwind) |
| |
| |
| class _TestPushOrSubSpParser(unittest.TestCase): |
| def testCfaChange(self): |
| parser = PushOrSubSpParser() |
| match = parser.GetBreakpadInstructionsRegex().search('.cfa: sp 4 +') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=0, |
| match=match) |
| |
| self.assertEqual(4, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=4, |
| registers=()), address_unwind) |
| |
| def testCfaAndRaChangePopOnly(self): |
| parser = PushOrSubSpParser() |
| match = parser.GetBreakpadInstructionsRegex().search( |
| '.cfa: sp 4 + .ra: .cfa -4 + ^') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=0, |
| match=match) |
| |
| self.assertEqual(4, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=0, |
| registers=(14, )), address_unwind) |
| |
| def testCfaAndRaChangePopAndSpUpdate(self): |
| parser = PushOrSubSpParser() |
| match = parser.GetBreakpadInstructionsRegex().search( |
| '.cfa: sp 8 + .ra: .cfa -4 + ^') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=0, |
| match=match) |
| |
| self.assertEqual(8, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=4, |
| registers=(14, )), address_unwind) |
| |
| def testCfaAndRaAndRegistersChangePopOnly(self): |
| parser = PushOrSubSpParser() |
| match = parser.GetBreakpadInstructionsRegex().search( |
| '.cfa: sp 12 + .ra: .cfa -4 + ^ r4: .cfa -12 + ^ r7: .cfa -8 + ^') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=0, |
| match=match) |
| |
| self.assertEqual(12, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=0, |
| registers=(4, 7, 14)), address_unwind) |
| |
| def testCfaAndRaAndRegistersChangePopAndSpUpdate(self): |
| parser = PushOrSubSpParser() |
| match = parser.GetBreakpadInstructionsRegex().search( |
| '.cfa: sp 16 + .ra: .cfa -4 + ^ r4: .cfa -12 + ^ r7: .cfa -8 + ^') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=0, |
| match=match) |
| |
| self.assertEqual(16, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=4, |
| registers=(4, 7, 14)), address_unwind) |
| |
| def testRegistersChange(self): |
| parser = PushOrSubSpParser() |
| match = parser.GetBreakpadInstructionsRegex().search( |
| 'r4: .cfa -8 + ^ r7: .cfa -4 + ^') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=0, |
| match=match) |
| |
| self.assertEqual(0, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=0, |
| registers=(4, 7)), address_unwind) |
| |
| def testCfaAndRegistersChange(self): |
| parser = PushOrSubSpParser() |
| match = parser.GetBreakpadInstructionsRegex().search( |
| '.cfa: sp 8 + r4: .cfa -8 + ^ r7: .cfa -4 + ^') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=0, |
| match=match) |
| |
| self.assertEqual(8, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=0, |
| registers=(4, 7)), address_unwind) |
| |
| def testRegistersOrdering(self): |
| parser = PushOrSubSpParser() |
| match = parser.GetBreakpadInstructionsRegex().search( |
| 'r10: .cfa -8 + ^ r7: .cfa -4 + ^') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=0, |
| match=match) |
| |
| self.assertEqual(0, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=0, |
| registers=(7, 10)), address_unwind) |
| |
| def testPoppingCallerSaveRegisters(self): |
| """Regression test for pop unwinds that encode caller-save registers. |
| |
| Callee-save registers: r0 ~ r3. |
| """ |
| parser = PushOrSubSpParser() |
| match = parser.GetBreakpadInstructionsRegex().search( |
| '.cfa: sp 16 + .ra: .cfa -4 + ^ ' |
| 'r3: .cfa -16 + ^ r4: .cfa -12 + ^ r5: .cfa -8 + ^') |
| |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=0, |
| match=match) |
| |
| self.assertEqual(16, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=4, |
| registers=(4, 5, 14)), address_unwind) |
| |
| |
| class _TestVPushParser(unittest.TestCase): |
| def testCfaAndRegistersChange(self): |
| parser = VPushParser() |
| match = parser.GetBreakpadInstructionsRegex().search( |
| '.cfa: sp 40 + unnamed_register264: .cfa -40 + ^ ' |
| 'unnamed_register265: .cfa -32 + ^') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=24, |
| match=match) |
| |
| self.assertEqual(40, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, |
| sp_offset=16, |
| registers=()), address_unwind) |
| |
| def testRegistersChange(self): |
| parser = VPushParser() |
| match = parser.GetBreakpadInstructionsRegex().search( |
| 'unnamed_register264: .cfa -40 + ^ unnamed_register265: .cfa -32 + ^') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=24, |
| match=match) |
| |
| self.assertEqual(24, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.NO_ACTION, |
| sp_offset=0, |
| registers=()), address_unwind) |
| |
| |
| class _TestStoreSpParser(unittest.TestCase): |
| def testCfaAndRegistersChange(self): |
| parser = StoreSpParser() |
| match = parser.GetBreakpadInstructionsRegex().search('.cfa: r7 8 +') |
| self.assertIsNotNone(match) |
| |
| address_unwind, new_cfa_sp_offset = parser.ParseFromMatch(address_offset=20, |
| cfa_sp_offset=12, |
| match=match) |
| |
| self.assertEqual(8, new_cfa_sp_offset) |
| self.assertEqual( |
| AddressUnwind(address_offset=20, |
| unwind_type=UnwindType.RESTORE_SP_FROM_REGISTER, |
| sp_offset=-4, |
| registers=(7, )), address_unwind) |
| |
| |
| class _TestEncodeUnwindInstructionTable(unittest.TestCase): |
| def testSingleEntry(self): |
| table, offsets = EncodeUnwindInstructionTable([bytes([3])]) |
| |
| self.assertEqual(bytes([3]), table) |
| self.assertDictEqual({ |
| bytes([3]): 0, |
| }, offsets) |
| |
| def testMultipleEntries(self): |
| self.maxDiff = None |
| # Result should be sorted by score descending. |
| table, offsets = EncodeUnwindInstructionTable([ |
| bytes([1, 2, 3]), |
| bytes([0, 3]), |
| bytes([3]), |
| ]) |
| self.assertEqual(bytes([3, 0, 3, 1, 2, 3]), table) |
| self.assertDictEqual( |
| { |
| bytes([1, 2, 3]): 3, # score = 1 / 3 = 0.67 |
| bytes([0, 3]): 1, # score = 1 / 2 = 0.5 |
| bytes([3]): 0, # score = 1 / 1 = 1 |
| }, |
| offsets) |
| |
| # When scores are same, sort by sequence descending. |
| table, offsets = EncodeUnwindInstructionTable([ |
| bytes([3]), |
| bytes([0, 3]), |
| bytes([0, 3]), |
| bytes([1, 2, 3]), |
| bytes([1, 2, 3]), |
| bytes([1, 2, 3]), |
| ]) |
| self.assertEqual(bytes([3, 1, 2, 3, 0, 3]), table) |
| self.assertDictEqual( |
| { |
| bytes([3]): 0, # score = 1 / 1 = 1 |
| bytes([1, 2, 3]): 1, # score = 3 / 3 = 1 |
| bytes([0, 3]): 4, # score = 2 / 2 = 1 |
| }, |
| offsets) |
| |
| |
| class _TestFunctionOffsetTable(unittest.TestCase): |
| def testSingleEntry(self): |
| self.maxDiff = None |
| complete_instruction_sequence0 = bytes([3]) |
| complete_instruction_sequence1 = bytes([1, 3]) |
| |
| sequence1 = ( |
| EncodedAddressUnwind(0x400, complete_instruction_sequence1), |
| EncodedAddressUnwind(0x0, complete_instruction_sequence0), |
| ) |
| |
| address_unwind_sequences = [sequence1] |
| |
| table, offsets = EncodeFunctionOffsetTable( |
| address_unwind_sequences, { |
| complete_instruction_sequence0: 52, |
| complete_instruction_sequence1: 50, |
| }) |
| |
| self.assertEqual( |
| bytes([ |
| # (0x200, 50) |
| 128, |
| 4, |
| 50, |
| # (0, 52) |
| 0, |
| 52, |
| ]), |
| table) |
| |
| self.assertDictEqual({ |
| sequence1: 0, |
| }, offsets) |
| |
| def testMultipleEntry(self): |
| self.maxDiff = None |
| complete_instruction_sequence0 = bytes([3]) |
| complete_instruction_sequence1 = bytes([1, 3]) |
| complete_instruction_sequence2 = bytes([2, 3]) |
| |
| sequence1 = ( |
| EncodedAddressUnwind(0x20, complete_instruction_sequence1), |
| EncodedAddressUnwind(0x0, complete_instruction_sequence0), |
| ) |
| sequence2 = ( |
| EncodedAddressUnwind(0x400, complete_instruction_sequence2), |
| EncodedAddressUnwind(0x0, complete_instruction_sequence0), |
| ) |
| address_unwind_sequences = [sequence1, sequence2] |
| |
| table, offsets = EncodeFunctionOffsetTable( |
| address_unwind_sequences, { |
| complete_instruction_sequence0: 52, |
| complete_instruction_sequence1: 50, |
| complete_instruction_sequence2: 80, |
| }) |
| |
| self.assertEqual( |
| bytes([ |
| # (0x10, 50) |
| 0x10, |
| 50, |
| # (0, 52) |
| 0, |
| 52, |
| # (0x200, 80) |
| 128, |
| 4, |
| 80, |
| # (0, 52) |
| 0, |
| 52, |
| ]), |
| table) |
| |
| self.assertDictEqual({ |
| sequence1: 0, |
| sequence2: 4, |
| }, offsets) |
| |
| def testDuplicatedEntry(self): |
| self.maxDiff = None |
| complete_instruction_sequence0 = bytes([3]) |
| complete_instruction_sequence1 = bytes([1, 3]) |
| complete_instruction_sequence2 = bytes([2, 3]) |
| |
| sequence1 = ( |
| EncodedAddressUnwind(0x20, complete_instruction_sequence1), |
| EncodedAddressUnwind(0x0, complete_instruction_sequence0), |
| ) |
| sequence2 = ( |
| EncodedAddressUnwind(0x400, complete_instruction_sequence2), |
| EncodedAddressUnwind(0x0, complete_instruction_sequence0), |
| ) |
| sequence3 = sequence1 |
| |
| address_unwind_sequences = [sequence1, sequence2, sequence3] |
| |
| table, offsets = EncodeFunctionOffsetTable( |
| address_unwind_sequences, { |
| complete_instruction_sequence0: 52, |
| complete_instruction_sequence1: 50, |
| complete_instruction_sequence2: 80, |
| }) |
| |
| self.assertEqual( |
| bytes([ |
| # (0x10, 50) |
| 0x10, |
| 50, |
| # (0, 52) |
| 0, |
| 52, |
| # (0x200, 80) |
| 128, |
| 4, |
| 80, |
| # (0, 52) |
| 0, |
| 52, |
| ]), |
| table) |
| |
| self.assertDictEqual({ |
| sequence1: 0, |
| sequence2: 4, |
| }, offsets) |
| |
| |
| class _TestEncodePageTableAndFunctionTable(unittest.TestCase): |
| def testMultipleFunctionUnwinds(self): |
| address_unwind_sequence0 = ( |
| EncodedAddressUnwind(0x10, bytes([0, 3])), |
| EncodedAddressUnwind(0x0, bytes([3])), |
| ) |
| address_unwind_sequence1 = ( |
| EncodedAddressUnwind(0x10, bytes([1, 3])), |
| EncodedAddressUnwind(0x0, bytes([3])), |
| ) |
| address_unwind_sequence2 = ( |
| EncodedAddressUnwind(0x200, bytes([2, 3])), |
| EncodedAddressUnwind(0x0, bytes([3])), |
| ) |
| |
| function_unwinds = [ |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=0, |
| address_unwinds=address_unwind_sequence0), |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=0x8000, |
| address_unwinds=address_unwind_sequence1), |
| EncodedFunctionUnwind(page_number=1, |
| page_offset=0x8000, |
| address_unwinds=address_unwind_sequence2), |
| ] |
| |
| function_offset_table_offsets = { |
| address_unwind_sequence0: 0x100, |
| address_unwind_sequence1: 0x200, |
| address_unwind_sequence2: 0x300, |
| } |
| |
| page_table, function_table = EncodePageTableAndFunctionTable( |
| function_unwinds, function_offset_table_offsets) |
| |
| self.assertEqual(2 * 4, len(page_table)) |
| self.assertEqual((0, 2), struct.unpack('2I', page_table)) |
| |
| self.assertEqual(6 * 2, len(function_table)) |
| self.assertEqual((0, 0x100, 0x8000, 0x200, 0x8000, 0x300), |
| struct.unpack('6H', function_table)) |
| |
| def testMultiPageFunction(self): |
| address_unwind_sequence0 = ( |
| EncodedAddressUnwind(0x10, bytes([0, 3])), |
| EncodedAddressUnwind(0x0, bytes([3])), |
| ) |
| address_unwind_sequence1 = ( |
| EncodedAddressUnwind(0x10, bytes([1, 3])), |
| EncodedAddressUnwind(0x0, bytes([3])), |
| ) |
| address_unwind_sequence2 = ( |
| EncodedAddressUnwind(0x200, bytes([2, 3])), |
| EncodedAddressUnwind(0x0, bytes([3])), |
| ) |
| |
| function_unwinds = [ |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=0, |
| address_unwinds=address_unwind_sequence0), |
| # Large function. |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=0x8000, |
| address_unwinds=address_unwind_sequence1), |
| EncodedFunctionUnwind(page_number=4, |
| page_offset=0x8000, |
| address_unwinds=address_unwind_sequence2), |
| ] |
| |
| function_offset_table_offsets = { |
| address_unwind_sequence0: 0x100, |
| address_unwind_sequence1: 0x200, |
| address_unwind_sequence2: 0x300, |
| } |
| |
| page_table, function_table = EncodePageTableAndFunctionTable( |
| function_unwinds, function_offset_table_offsets) |
| |
| self.assertEqual(5 * 4, len(page_table)) |
| self.assertEqual((0, 2, 2, 2, 2), struct.unpack('5I', page_table)) |
| |
| self.assertEqual(6 * 2, len(function_table)) |
| self.assertEqual((0, 0x100, 0x8000, 0x200, 0x8000, 0x300), |
| struct.unpack('6H', function_table)) |
| |
| |
| class MockReturnParser(UnwindInstructionsParser): |
| def GetBreakpadInstructionsRegex(self): |
| return re.compile(r'^RETURN$') |
| |
| def ParseFromMatch(self, address_offset, cfa_sp_offset, match): |
| return AddressUnwind(address_offset, UnwindType.RETURN_TO_LR, 0, ()), 0 |
| |
| |
| class MockEpilogueUnwindParser(UnwindInstructionsParser): |
| def GetBreakpadInstructionsRegex(self): |
| return re.compile(r'^EPILOGUE_UNWIND$') |
| |
| def ParseFromMatch(self, address_offset, cfa_sp_offset, match): |
| return AddressUnwind(address_offset, |
| UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, 0, ()), -100 |
| |
| |
| class MockWildcardParser(UnwindInstructionsParser): |
| def GetBreakpadInstructionsRegex(self): |
| return re.compile(r'.*') |
| |
| def ParseFromMatch(self, address_offset, cfa_sp_offset, match): |
| return AddressUnwind(address_offset, |
| UnwindType.UPDATE_SP_AND_OR_POP_REGISTERS, 0, ()), -200 |
| |
| |
| class _TestParseAddressCfi(unittest.TestCase): |
| def testSuccessParse(self): |
| address_unwind = AddressUnwind( |
| address_offset=0x300, |
| unwind_type=UnwindType.RETURN_TO_LR, |
| sp_offset=0, |
| registers=(), |
| ) |
| |
| self.assertEqual((address_unwind, False, 0), |
| ParseAddressCfi(AddressCfi(address=0x800, |
| unwind_instructions='RETURN'), |
| function_start_address=0x500, |
| parsers=(MockReturnParser(), ), |
| prev_cfa_sp_offset=0)) |
| |
| def testUnhandledAddress(self): |
| self.assertEqual((None, False, 100), |
| ParseAddressCfi(AddressCfi(address=0x800, |
| unwind_instructions='UNKNOWN'), |
| function_start_address=0x500, |
| parsers=(MockReturnParser(), ), |
| prev_cfa_sp_offset=100)) |
| |
| def testEpilogueUnwind(self): |
| self.assertEqual( |
| (None, True, -100), |
| ParseAddressCfi(AddressCfi(address=0x800, |
| unwind_instructions='EPILOGUE_UNWIND'), |
| function_start_address=0x500, |
| parsers=(MockEpilogueUnwindParser(), ), |
| prev_cfa_sp_offset=100)) |
| |
| def testParsePrecedence(self): |
| address_unwind = AddressUnwind( |
| address_offset=0x300, |
| unwind_type=UnwindType.RETURN_TO_LR, |
| sp_offset=0, |
| registers=(), |
| ) |
| |
| self.assertEqual( |
| (address_unwind, False, 0), |
| ParseAddressCfi(AddressCfi(address=0x800, unwind_instructions='RETURN'), |
| function_start_address=0x500, |
| parsers=(MockReturnParser(), MockWildcardParser()), |
| prev_cfa_sp_offset=0)) |
| |
| |
| class _TestGenerateUnwinds(unittest.TestCase): |
| def testSuccessUnwind(self): |
| self.assertEqual( |
| [ |
| FunctionUnwind(address=0x100, |
| size=1024, |
| address_unwinds=( |
| AddressUnwind( |
| address_offset=0x0, |
| unwind_type=UnwindType.RETURN_TO_LR, |
| sp_offset=0, |
| registers=(), |
| ), |
| AddressUnwind( |
| address_offset=0x200, |
| unwind_type=UnwindType.RETURN_TO_LR, |
| sp_offset=0, |
| registers=(), |
| ), |
| )) |
| ], |
| list( |
| GenerateUnwinds([ |
| FunctionCfi( |
| size=1024, |
| address_cfi=( |
| AddressCfi(address=0x100, unwind_instructions='RETURN'), |
| AddressCfi(address=0x300, unwind_instructions='RETURN'), |
| )) |
| ], |
| parsers=[MockReturnParser()]))) |
| |
| def testUnhandledAddress(self): |
| self.assertEqual( |
| [ |
| FunctionUnwind(address=0x100, |
| size=1024, |
| address_unwinds=(AddressUnwind( |
| address_offset=0x0, |
| unwind_type=UnwindType.RETURN_TO_LR, |
| sp_offset=0, |
| registers=(), |
| ), )) |
| ], |
| list( |
| GenerateUnwinds([ |
| FunctionCfi(size=1024, |
| address_cfi=( |
| AddressCfi(address=0x100, |
| unwind_instructions='RETURN'), |
| AddressCfi(address=0x300, |
| unwind_instructions='UNKNOWN'), |
| )) |
| ], |
| parsers=[MockReturnParser()]))) |
| |
| def testEpilogueUnwind(self): |
| self.assertEqual( |
| [ |
| FunctionUnwind(address=0x100, |
| size=1024, |
| address_unwinds=(AddressUnwind( |
| address_offset=0x0, |
| unwind_type=UnwindType.RETURN_TO_LR, |
| sp_offset=0, |
| registers=(), |
| ), )) |
| ], |
| list( |
| GenerateUnwinds([ |
| FunctionCfi( |
| size=1024, |
| address_cfi=( |
| AddressCfi(address=0x100, unwind_instructions='RETURN'), |
| AddressCfi(address=0x300, |
| unwind_instructions='EPILOGUE_UNWIND'), |
| )) |
| ], |
| parsers=[ |
| MockReturnParser(), |
| MockEpilogueUnwindParser() |
| ]))) |
| |
| def testInvalidInitialUnwindInstructionAsserts(self): |
| self.assertRaises( |
| AssertionError, lambda: list( |
| GenerateUnwinds([ |
| FunctionCfi(size=1024, |
| address_cfi=( |
| AddressCfi(address=0x100, |
| unwind_instructions='UNKNOWN'), |
| AddressCfi(address=0x200, |
| unwind_instructions='RETURN'), |
| )) |
| ], |
| parsers=[MockReturnParser()]))) |
| |
| |
| class _TestEncodeUnwindInfo(unittest.TestCase): |
| def testEncodeTables(self): |
| page_table = struct.pack('I', 0) |
| function_table = struct.pack('4H', 1, 2, 3, 4) |
| function_offset_table = bytes([1, 2]) |
| unwind_instruction_table = bytes([1, 2, 3]) |
| |
| unwind_info = EncodeUnwindInfo( |
| page_table, |
| function_table, |
| function_offset_table, |
| unwind_instruction_table, |
| ) |
| |
| self.assertEqual( |
| 32 + len(page_table) + len(function_table) + |
| len(function_offset_table) + len(unwind_instruction_table), |
| len(unwind_info)) |
| # Header. |
| self.assertEqual((32, 1, 36, 2, 44, 2, 46, 3), |
| struct.unpack('8I', unwind_info[:32])) |
| # Body. |
| self.assertEqual( |
| page_table + function_table + function_offset_table + |
| unwind_instruction_table, unwind_info[32:]) |
| |
| def testUnalignedTables(self): |
| self.assertRaises( |
| AssertionError, lambda: EncodeUnwindInfo(bytes([1]), b'', b'', b'')) |
| self.assertRaises( |
| AssertionError, lambda: EncodeUnwindInfo(b'', bytes([1]), b'', b'')) |
| |
| |
| class _TestGenerateUnwindTables(unittest.TestCase): |
| def testGenerateUnwindTables(self): |
| """This is an integration test that hooks everything together. """ |
| address_unwind_sequence0 = ( |
| EncodedAddressUnwind(0x20, bytes([0, 0xb0])), |
| EncodedAddressUnwind(0x0, bytes([0xb0])), |
| ) |
| address_unwind_sequence1 = ( |
| EncodedAddressUnwind(0x20, bytes([1, 0xb0])), |
| EncodedAddressUnwind(0x0, bytes([0xb0])), |
| ) |
| address_unwind_sequence2 = ( |
| EncodedAddressUnwind(0x200, bytes([2, 0xb0])), |
| EncodedAddressUnwind(0x0, bytes([0xb0])), |
| ) |
| |
| (page_table, function_table, function_offset_table, |
| unwind_instruction_table) = GenerateUnwindTables([ |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=0, |
| address_unwinds=TRIVIAL_UNWIND), |
| EncodedFunctionUnwind(page_number=0, |
| page_offset=0x1000, |
| address_unwinds=address_unwind_sequence0), |
| EncodedFunctionUnwind(page_number=1, |
| page_offset=0x2000, |
| address_unwinds=address_unwind_sequence1), |
| EncodedFunctionUnwind(page_number=3, |
| page_offset=0x1000, |
| address_unwinds=address_unwind_sequence2), |
| ]) |
| |
| # Complete instruction sequences and their frequencies. |
| # [0xb0]: 4 |
| # [0, 0xb0]: 1 |
| # [1, 0xb0]: 1 |
| # [2, 0xb0]: 1 |
| self.assertEqual(bytes([0xb0, 2, 0xb0, 1, 0xb0, 0, 0xb0]), |
| unwind_instruction_table) |
| |
| self.assertEqual( |
| bytes([ |
| # Trivial unwind. |
| 0, |
| 0, |
| # Address unwind sequence 0. |
| 0x10, |
| 5, |
| 0, |
| 0, |
| # Address unwind sequence 1. |
| 0x10, |
| 3, |
| 0, |
| 0, |
| # Address unwind sequence 2. |
| 0x80, |
| 2, |
| 1, |
| 0, |
| 0, |
| ]), |
| function_offset_table) |
| |
| self.assertEqual(8 * 2, len(function_table)) |
| self.assertEqual((0, 0, 0x1000, 2, 0x2000, 6, 0x1000, 10), |
| struct.unpack('8H', function_table)) |
| |
| self.assertEqual(4 * 4, len(page_table)) |
| self.assertEqual((0, 2, 3, 3), struct.unpack('4I', page_table)) |
