test/unit/test_dwarf.py

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)