| import os |
| import subprocess |
| import tempfile |
| |
| from scripts.test import shared |
| |
| from . import utils |
| |
| |
| class DWARFTest(utils.BinaryenTestCase): |
| def test_overlapping_inline_siblings(self): |
| # Make the outer lexical block valid and move one inlined call onto |
| # its sibling's range. Both siblings must become unavailable: keeping |
| # either one would assign its variables to the other's instructions. |
| path = os.path.join(shared.options.binaryen_test, 'passes', |
| 'class_with_dwarf_noprint.wasm') |
| with open(path, 'rb') as f: |
| wasm = f.read() |
| replacements = ( |
| ('26000000fcffffff', '260000005f000000'), |
| ('4000000019000000', '6100000009000000'), |
| ) |
| for old, new in replacements: |
| old_bytes = bytes.fromhex(old) |
| self.assertEqual(wasm.count(old_bytes), 1) |
| wasm = wasm.replace(old_bytes, bytes.fromhex(new)) |
| |
| with tempfile.TemporaryDirectory() as temp_dir: |
| input_file = os.path.join(temp_dir, 'input.wasm') |
| output_file = os.path.join(temp_dir, 'output.wasm') |
| with open(input_file, 'wb') as f: |
| f.write(wasm) |
| shared.run_process(shared.WASM_OPT + |
| [input_file, '--roundtrip', '-g', |
| '-o', output_file]) |
| dump = shared.run_process(shared.WASM_OPT + |
| [output_file, '--dwarfdump'], |
| capture_output=True).stdout |
| first = dump.split('0x0000015e:', 1)[1].split('0x00000179:', 1)[0] |
| second = dump.split('0x00000179:', 1)[1].split('0x00000189:', 1)[0] |
| ranges_line = next(line for line in first.splitlines() |
| if 'DW_AT_ranges' in line) |
| self.assertTrue(ranges_line.endswith(')')) |
| empty_offset = ranges_line.rsplit('(0x', 1)[1].split(')', 1)[0] |
| ranges = dump.split('.debug_ranges contents:', 1)[1] |
| self.assertIn(f'{empty_offset} <End of list>', ranges) |
| self.assertIn('DW_AT_low_pc [DW_FORM_addr]\t' |
| '(0x00000000ffffffff)', second) |
| |
| def test_zero_start_range_offset(self): |
| # A zero start with a nonzero end is a valid offset from the current |
| # .debug_ranges base, not a tombstone or end-of-list marker. Replace |
| # the fixture's unmapped (0, 1) entry with a contiguous mapped range. |
| path = os.path.join(shared.options.binaryen_test, 'passes', |
| 'class_with_dwarf_noprint.wasm') |
| with open(path, 'rb') as f: |
| wasm = f.read() |
| old_ranges = bytes.fromhex('00000000010000005b00000064000000') |
| new_ranges = bytes.fromhex('000000005b0000005b00000064000000') |
| self.assertEqual(wasm.count(old_ranges), 1) |
| wasm = wasm.replace(old_ranges, new_ranges) |
| |
| with tempfile.TemporaryDirectory() as temp_dir: |
| input_file = os.path.join(temp_dir, 'input.wasm') |
| output_file = os.path.join(temp_dir, 'output.wasm') |
| with open(input_file, 'wb') as f: |
| f.write(wasm) |
| shared.run_process(shared.WASM_OPT + |
| [input_file, '--roundtrip', '-g', |
| '-o', output_file]) |
| dump = shared.run_process(shared.WASM_OPT + |
| [output_file, '--dwarfdump'], |
| capture_output=True).stdout |
| ranges = dump.split('.debug_ranges contents:', 1)[1] |
| self.assertRegex( |
| '\n'.join(ranges.splitlines()), |
| r'(?m)^00000000 00000000 (?!00000000)[0-9a-f]{8}$') |
| |
| def test_tombstone_roundtrip(self): |
| def custom_section(name, contents): |
| name = name.encode() |
| payload = bytes([len(name)]) + name + contents |
| self.assertLess(len(payload), 128) |
| return bytes([0, len(payload)]) + payload |
| |
| # A minimal DWARF v4 unit whose compile unit and subprogram both use |
| # the all-ones dead-address sentinel for DW_AT_low_pc. |
| sections = { |
| '.debug_abbrev': '011101030e110112060000022e0011011206030e000000', |
| '.debug_info': ('22000000040000000000040100000000ffffffff' |
| '0300000002ffffffff030000000f00000000'), |
| '.debug_str': '746573742d636c616e672e63707000666f6f00', |
| } |
| wasm = bytes.fromhex('0061736d01000000') |
| for name, contents in sections.items(): |
| wasm += custom_section(name, bytes.fromhex(contents)) |
| |
| with tempfile.TemporaryDirectory() as temp_dir: |
| input_file = os.path.join(temp_dir, 'input.wasm') |
| output_file = os.path.join(temp_dir, 'output.wasm') |
| with open(input_file, 'wb') as f: |
| f.write(wasm) |
| shared.run_process(shared.WASM_OPT + |
| [input_file, '--roundtrip', '-g', |
| '-o', output_file]) |
| dump = shared.run_process(shared.WASM_OPT + |
| [output_file, '--dwarfdump'], |
| capture_output=True).stdout |
| self.assertEqual(dump.count('0x00000000ffffffff'), 2) |
| |
| def test_missing_start_with_mapped_end(self): |
| # The unused subprogram starts at zero (no location mapping). Point its |
| # relative high_pc at the end of the preceding live subprogram. The |
| # surviving end must not make the missing start look like a live scope. |
| path = os.path.join(shared.options.binaryen_test, 'passes', |
| 'ignore_missing_func_dwarf.wasm') |
| with open(path, 'rb') as f: |
| wasm = f.read() |
| old_pair = bytes.fromhex('000000005a000000') |
| self.assertEqual(wasm.count(old_pair), 1) |
| wasm = wasm.replace(old_pair, bytes.fromhex('000000005f000000')) |
| |
| with tempfile.TemporaryDirectory() as temp_dir: |
| input_file = os.path.join(temp_dir, 'input.wasm') |
| output_file = os.path.join(temp_dir, 'output.wasm') |
| with open(input_file, 'wb') as f: |
| f.write(wasm) |
| shared.run_process(shared.WASM_OPT + |
| [input_file, '--roundtrip', '-g', |
| '-o', output_file]) |
| dump = shared.run_process(shared.WASM_OPT + |
| [output_file, '--dwarfdump'], |
| capture_output=True).stdout |
| unused = next(part for part in dump.split('DW_TAG_subprogram') |
| if '"unused"' in part) |
| self.assertIn('DW_AT_low_pc [DW_FORM_addr]\t' |
| '(0x00000000ffffffff)', unused) |
| |
| def test_memory64_range_list_fallback(self): |
| # This fixture is a two-function wasm64 module with a DWARF v4 CU and |
| # .debug_ranges, compiled using clang --target=wasm64-unknown-unknown |
| # -O1 -g. The vendored emitter still writes 4-byte range entries, so |
| # range-list repair must not append an invalid 8-byte-CU offset. |
| input_file = self.input_path('dwarf/memory64_ranges.wasm') |
| with tempfile.TemporaryDirectory() as temp_dir: |
| output_file = os.path.join(temp_dir, 'output.wasm') |
| shared.run_process(shared.WASM_OPT + |
| [input_file, '--roundtrip', '-g', |
| '-o', output_file]) |
| dump = shared.run_process(shared.WASM_OPT + |
| [output_file, '--dwarfdump'], |
| capture_output=True).stdout |
| self.assertIn('DW_AT_ranges [DW_FORM_sec_offset]\t(0x00000000', |
| dump) |
| |
| def test_no_crash(self): |
| # run dwarf processing on some interesting large files, too big to be |
| # worth putting in passes where the text output would be massive. We |
| # just check that no assertion are hit. |
| path = self.input_path('dwarf') |
| for name in os.listdir(path): |
| if not name.endswith('.wasm'): |
| continue |
| args = [os.path.join(path, name)] + \ |
| ['-g', '--dwarfdump', '--roundtrip', '--dwarfdump'] |
| shared.run_process(shared.WASM_OPT + args, capture_output=True) |
| |
| def test_dwarf_incompatibility(self): |
| warning = 'not fully compatible with DWARF' |
| path = self.input_path(os.path.join('dwarf', 'cubescript.wasm')) |
| args = [path, '-g'] |
| # flatten warns |
| err = shared.run_process(shared.WASM_OPT + args + ['--flatten'], stderr=subprocess.PIPE).stderr |
| self.assertIn(warning, err) |
| # safe passes do not |
| err = shared.run_process(shared.WASM_OPT + args + ['--metrics'], stderr=subprocess.PIPE).stderr |
| self.assertNotIn(warning, err) |
| |
| def test_strip_dwarf_and_opts(self): |
| # some optimizations are disabled when DWARF is present (as they would |
| # destroy it). we scan the wasm to see if there is any DWARF when |
| # making the decision whether to run them. this test checks that we also |
| # check if --strip* is being run, which would remove the DWARF anyhow |
| path = self.input_path(os.path.join('dwarf', 'cubescript.wasm')) |
| # strip the DWARF, then run all the opts to check as much as possible |
| args = [path, '--strip-dwarf', '-Oz'] |
| # run it normally, without -g. in this case no DWARF will be preserved |
| # in a trivial way |
| shared.run_process(shared.WASM_OPT + args + ['-o', 'a.wasm']) |
| # run it with -g. in this case we need to be clever as described above, |
| # and see --strip-dwarf removes the need for DWARF |
| shared.run_process(shared.WASM_OPT + args + ['-o', 'b.wasm', '-g']) |
| # run again on the last output without -g, as we don't want the names |
| # section to skew the results |
| shared.run_process(shared.WASM_OPT + ['b.wasm', '-o', 'c.wasm']) |
| # compare the sizes. there might be a tiny difference in size to to |
| # minor roundtrip changes, so ignore up to a tiny % |
| a_size = os.path.getsize('a.wasm') |
| c_size = os.path.getsize('c.wasm') |
| self.assertLess((100 * abs(a_size - c_size)) / c_size, 1) |
