Check if debug line sequences are starting after the first code segment

[aadsm]

Summary

I found a few cases where entries in the debug_line for a specific line of code have invalid entries (the address is outside of a code section or no section at all) and also valid entries. When this happens lldb might not set the breakpoint because the first line entry it will find in the line table might be the invalid one and since it's range is "invalid" no location is resolved. To get around this I changed the way we parse the line sequences to ignore those starting at an address under the first code segment.
Greg suggested to implement it this way so we don't need to check all sections for every line sequence.

[aadsm]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

441

I'm actually not 100% sure about this, can there be new code sections added after this?

lldb/unittests/SymbolFile/DWARF/Inputs/test-invalid-offsets.yaml

520 ↗

(On Diff #290049)

I generated this yaml with the code that is at the top, and then changed it to replicate the bug ,here's what the line table looks like:

Address            Line   Column File   ISA Discriminator Flags
------------------ ------ ------ ------ --- ------------- -------------
0x0000000100000f80      1      0      1   0             0  is_stmt
0x0000000100000f84      2      5      1   0             0  is_stmt prologue_end
0x0000000100000f8b      2      5      1   0             0  is_stmt end_sequence
0x0000000100000f90      5      0      1   0             0  is_stmt
0x0000000100000f90      5      0      1   0             0  is_stmt end_sequence
0x000000000000000f      2     13      1   0             0  is_stmt prologue_end
0x0000000000000014      2      9      1   0             0
0x0000000000000017      3     12      1   0             0  is_stmt
0x000000000000001d      3     12      1   0             0  end_sequence

Now that I think about it maybe I should also copy this into this file as a comment.

[aadsm]

lldb/unittests/SymbolFile/DWARF/Inputs/test-invalid-offsets.yaml

1 ↗

(On Diff #290049)

I should rename this to test-invalid-addresses.yaml instead.

[clayborg]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

437–441

This should be fine. Any symbol files that might get added after the fact really need to have matching sections or nothing will make sense.

1063

Add a comment here about attempting to avoid line tables that should have been dead stripped.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

523

A lengthy comment would be great here. Maybe something like:

/// Many linkers will concatenate all available DWARF, even if parts of that DWARF
/// should have been dead stripped. Some linkers will place tombstone values in for
/// addresses that should have been dead stripped, with a value like -1 or -2. But many
/// linkers will apply a relocation and attempt to set the value to zero. This is problematic
/// in that we can end up with many addresses that are zero or close to zero due to there
/// being an addend on the relocation whose base is at zero. Here we attempt to avoid 
/// addresses that are zero or close to zero by finding the first valid code address by looking
/// at the sections and finding the first one that has read + execute permissions. This allows
/// us to do a quick and cheap comparison against this address when parsing line tables and
/// parsing functions where the DWARF should have been dead stripped.

lldb/unittests/SymbolFile/DWARF/Inputs/test-invalid-offsets.yaml

520 ↗

(On Diff #290049)

Would line table work just fine without your fix since the good address comes first? Or do we end up with multiple locations? I thought I remembered you thinking that it would pick the first one. Am I remembering correctly?

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

74 ↗

(On Diff #290049)

remove whitespace only changes please. Ditto for all whitespace only changes below.

[aadsm]

lldb/unittests/SymbolFile/DWARF/Inputs/test-invalid-offsets.yaml

520 ↗

(On Diff #290049)

yeah, I was wrong, they end up being order by address, so the issue is there.

[aadsm]

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

74 ↗

(On Diff #290049)

Can I make an argument to allow this on diffs? Most repos have a no trailing whitespace rule and because of this most editors are configured to remote trailing whitespaces on save. I've also just checked this is the case for LLVM: https://llvm.org/docs/CodingStandards.html#whitespace

I can either:

1. git add -i (which is a pain), or
2. configure my editor to not remove trailing white spaces for this project (which I guess it should be fine since clang-format takes care of it in the end)

Doing 2) is pretty easy to me (but it also means everyone else has to do it), since LLVM code convention is to disallow trailing whitespaces I could split this into 2 diffs, one with the bug fix and another one with trailing whitespace removal only (so no one else has the same problem with this file in the future). I don't see what is the advantage of having 2 diffs (just more work) so that's why I'm making the case to allow removal of trailing whitespaces in the files of a diff.

What do you think?

[aadsm]

Address comments

[labath]

This is fixing the same issue that I tried to fix with D84402, but then failed to get back to it when the discussion about the best approach started getting long. While I do have some reservations about this approach, it is definitive improvement than the status quo, so I won't start bikeshedding the design (but do see the inline comments)..

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

437

This is really the _first_ text section (as listed in the section headers), is it not? But, I assume you really want the section with the lowest file address?

The linkers (and other producers) will normally output the sections in ascending address order (because it's the simplest thing to do). However, I don't believe that is actually required by anything, and I /think/ it should be possible (with a moderately funky linker script) to produce a fully functional executable which does not have the sections listed in this order.

437–441

Doing this in InitializeObject would be better.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

523

To me, "should have been stripped" implies that the linkers are doing something wrong, as if they were required to parse and rewrite the dwarf in the input files. However, there is nothing in the DWARF or ELF specs that would support that, and the linkers are simply doing what the specs say, and what linkers have been doing since the dawn of time -- concatenate things.

It would be better to just state the facts here, instead of passing judgement (or make an appearance of doing that).

lldb/unittests/SymbolFile/DWARF/Inputs/test-invalid-addresses.yaml

1–8 ↗

(On Diff #290112)

Is this the actual source code, or you've made some changes to it (like, to change the line table start address)?

203–254 ↗

(On Diff #290112)

I guess these (and debug_pub(types/names), and possible debug_aranges) are not really needed for this test.

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

349–369 ↗

(On Diff #290112)

I think this would be better as a shell test (if for nothing else, then because other line table tests are written that way). image lookup is pretty much a direct equivalent to ResolveSymbolContext, but its output is more readable, and its easier to fiddle with these kinds of tests.

[aadsm]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

523

@clayborg can you clarify this comment like @labath suggests?

lldb/unittests/SymbolFile/DWARF/Inputs/test-invalid-addresses.yaml

203–254 ↗

(On Diff #290112)

I changed the line table by hand but forgot to add comments there.

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

349–369 ↗

(On Diff #290112)

I think what you describe is an end to end test but here I explicitly want to test the SymbolFileDWARF code because that's what I changed, it's more like a unit test.
I would prefer to stay away from an end to end test for this particular change because 1) knowing that image lookup calls ResolveSymbolContext is an implementation detail 2) The output of image lookup could change over time, 3) Other bugs unrelated to this could be introduced that will make image lookup show a different content as well and fail the test.

[labath]

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

349–369 ↗

(On Diff #290112)

On most days I am a proponent of unit tests, so I feel slightly odd for writing this, but here it goes...

I think you'll find that a lot of people in the llvm community (which now has a pretty big (but not as big as I'd like) intersection with the lldb community) are not very enthusiastic about (c++) unit tests. They concede they have their place, but are generally trying to avoid it. Some would rather create a brand new command line tool wrapping an api (and then test that via lit) than to write a unit test for it. Some effects of that can be seen in the design of the lldb-test tool.

Although this approach, when taken to extremes, can be bad, I believe it has it's advantages, for several reasons:

• changing the test does not require recompilation
• due to more people using it, more people are aware of how these tests work (easier for them to inspect/modify it)
• for similar reasons, the infrastructure supporting these tests is better. E.g., for the lit test, I can choose whether to generate the test binary via yaml2obj, llvm-mc, clang, or something completely different. unit tests only have yaml2obj available and for a long time it was implemented by shelling out to the external binary.

Your points about the issues with lit tests are not untrue, but I wouldn't say they are more true for this test than they are for any other of our lit tests, so I don't see a need to treat this test specially.

It's definitely true that the lit test will be more broad that this unit test, but it's still pretty far from a end-to-end test. A lot of our end-to-end tests for dwarf features start by compiling some c++ codes (hoping it produces the right dwarf), running the code, and then inspecting the running process. That's something I'm trying to change (not very successfully). Compared to that, "image lookup" is peanuts. Although you the fact that it's implemented by ResolveSymbolContext is kind of an implementation detail, I would say that if it was *not* implemented this way (and e.g. reimplemented some of that functionality) that we have bigger problems.

[clayborg]

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

369 ↗

(On Diff #290112)

I would rather deal with an C++ unit test any day. Trying to track down what set of convoluted command line commands reproduce some lit test is quite annoying and takes me a lot more time to debug. I think this test is targeted and tests what is needed. I would vote to keep this one over converting to a text dump test. My main reasoning is that it isn't possible to re-create a compilable test case that will survive any compiler that it used (past, present and future), and all symbol resolution is done bone using this call in all cases. When something goes wrong, very easy to compile the binary and debug.

[clayborg]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

437

We do need to iterate over all sections and find the one with the lowest address, good catch. No sorting is required in object files.

441

And doing the work in InitializeObject() is better.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

523

Fine to reword this to not appear hostile toward the linkers. If any judgement should be passed, it should be on the DWARF format itself and how unfriendly it is to link!

[labath]

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

369 ↗

(On Diff #290112)

If we put this up for a vote, I think you'd be in the minority. :)

I'm not sure what you find hard about reproducing a lit test -- the commands to do that get printed as a part of the test. And most of the time you don't need to run all the command to reproduce it -- running the last one suffices as the intermediate files are left over from the previous test run. I consider the leftover temporaries as one of the best aspects of this method. In this case, I could for example run llvm-dwarfdump on the intermediate object file to better understand the input that lldb gets.

Note that I am not advocating changing the test input to c++ source. I think the yaml is just fine (if I was writing it, I would probably have made that an assembler file). I just meant changing the test method by prefixing the yaml with something like:

# RUN: yaml2obj %s > %t
# RUN: %lldb %t -b -o "image lookup -f main.cpp -l 2" | FileCheck %s
# CHECK: LineEntry: {{.*}}main.cpp:2 # or something like that

[clayborg]

lldb/unittests/SymbolFile/DWARF/SymbolFileDWARFTests.cpp

369 ↗

(On Diff #290112)

If we put this up for a vote, I think you'd be in the minority. :)

I'm not sure what you find hard about reproducing a lit test -- the commands to do that get printed as a part of the test. And most of the time you don't need to run all the command to reproduce it -- running the last one suffices as the intermediate files are left over from the previous test run. I consider the leftover temporaries as one of the best aspects of this method. In this case, I could for example run llvm-dwarfdump on the intermediate object file to better understand the input that lldb gets.

Note that I am not advocating changing the test input to c++ source. I think the yaml is just fine (if I was writing it, I would probably have made that an assembler file). I just meant changing the test method by prefixing the yaml with something like:

# RUN: yaml2obj %s > %t
# RUN: %lldb %t -b -o "image lookup -f main.cpp -l 2" | FileCheck %s
# CHECK: LineEntry: {{.*}}main.cpp:2 # or something like that

If it is that easy, then sounds good. I was thinking you were asking him to add new functionality for dumping something.

[aadsm]

Addressed all comments:

• Moved initialization code to InitializeObject
• Moved to lit test

[labath]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

506

Shouldn't this be also checking the permissions?

lldb/test/Shell/SymbolFile/DWARF/line-entries-invalid-addresses.yaml

4

I think you also need to check for the "1 matches found", otherwise this will succeed even without the patch.

[clayborg]

See inlined comments for full details.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

506

Yes we need to check permissions. But we also have to watch out for sections that contain sections. For ELF, we have the PT_LOAD[N] sections that contain sections. On Mac, we have TEXT that contains sections, but the first section can be PAGEZERO (which has no read, no write, no execute).

So the main question becomes: if a section contains subsections, do we ignore the top level section? I would prefer to see us do this.

So this code should be factored into a lambda or function:

bool SymbolFileDWARF::SetFirstCodeAddress(const SectionList &section_list) {
  const uint32_t num_sections = section_list.GetSize();
  for (uint32_t i = 0; i < num_sections; ++i) {
    SectionSP section_sp(section_list.GetSectionAtIndex(i));
    if (sections_sp->GetChildren().GetSize() > 0) {
        SetFirstCodeAddress(sections_sp->GetChildren());
        continue;
    }
    if (HasExecutePermissions(section_sp)) {
      const addr_t section_file_address = section_sp->GetFileAddress();
      if (m_first_code_address > section_file_address)
        m_first_code_address = section_file_address;
    }
  }
}

And then this code will just look like:

const SectionList *section_list = m_objfile_sp->GetModule()->GetSectionList();
if (section_list)
  SetFirstCodeAddress(*section_list);

[aadsm]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

506

Sorry about this. I completely changed the original logic with my last update. I was checking the section type before and also going down the section hierarchy but not anymore.

We should go through all sub sections just like I did in my original code, I was also checking if it was a code section, rather than permissions, it's a bit more abstract that way.

[aadsm]

lldb/test/Shell/SymbolFile/DWARF/line-entries-invalid-addresses.yaml

4

This should be fine, this is what you get without the patch:

(lldb) image lookup -f main.cpp -l 2 -v
1 match found in main.cpp:2 in /Users/aadsm/Projects/test-bad.obj:
        Address:  ()
        Summary:

[aadsm]

Check all child sections and makes sure the section is an actual code section.

[clayborg]

Just remove the braces as suggested in inline comments. Pavel?

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

503–505

remove braces

[labath]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

503–505

or even fold the declaration into the if condition.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

523

How about this:

DWARF does not provide a good way for traditional (concatenating) linkers to invalidate debug info describing dead-stripped code. These linkers will keep the debug info but resolve any addresses referring to such code as zero (BFD), a small positive integer (zero + relocation addend -- GOLD), or -1/-2 (LLD). Try to filter out this debug info by comparing it to the lowest code address in the module.

lldb/test/Shell/SymbolFile/DWARF/line-entries-invalid-addresses.yaml

4

True, but adding the check still wouldn't hurt, as one can imagine a bug that would cause the second main.cpp:2 entry (at address 0xf) to make its way here -- and that's what we're trying to avoid.

[aadsm]

• Fixed formatting issues
• Updated comment on the reason we need to do this
• Improved the lit test by also checking how many matches it found

[aadsm]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

503–505

folding was not possible as clang-formatter didn't allow it.

[labath]

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

503–505

I meant:

if(const SectionList *section_list = m_objfile_sp->GetModule()->GetSectionList())
  InitializeFirstCodeAddress(*section_list);

We have plently of code like that, so clang-format should not have a problem.

[aadsm]

reverting because I'm not able to repro the fails, so need more time to figure it out.

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

 //===-- SymbolFileDWARF.h --------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARF_H
 #define LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARF_H
 
 #include <list>
 #include <map>
 #include <mutex>
 #include <unordered_map>
 #include <vector>
 
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SetVector.h"
 #include "llvm/Support/Threading.h"
 
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Symbol/DebugMacros.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Flags.h"
 #include "lldb/Utility/RangeMap.h"
 #include "lldb/lldb-private.h"
struct DecodedUID {
     DIERef ref;
   };
   llvm::Optional<DecodedUID> DecodeUID(lldb::user_id_t uid);
 
   void FindDwpSymbolFile();
 
   const lldb_private::FileSpecList &GetTypeUnitSupportFiles(DWARFTypeUnit &tu);
 
+  void
+  InitializeFirstCodeAddress(const lldb_private::SectionList &section_list);
+
   lldb::ModuleWP m_debug_map_module_wp;
   SymbolFileDWARFDebugMap *m_debug_map_symfile;
 
   llvm::once_flag m_dwp_symfile_once_flag;
   std::shared_ptr<SymbolFileDWARFDwo> m_dwp_symfile;
 
   lldb_private::DWARFContext m_context;
 
protected:
   UniqueDWARFASTTypeMap m_unique_ast_type_map;
   DIEToTypePtr m_die_to_type;
   DIEToVariableSP m_die_to_variable_sp;
   DIEToClangType m_forward_decl_die_to_clang_type;
   ClangTypeToDIE m_forward_decl_clang_type_to_die;
   llvm::DenseMap<dw_offset_t, lldb_private::FileSpecList>
       m_type_unit_support_files;
   std::vector<uint32_t> m_lldb_cu_to_dwarf_unit;
+  /// DWARF does not provide a good way for traditional (concatenating) linkers
+  /// to invalidate debug info describing dead-stripped code. These linkers will
+  /// keep the debug info but resolve any addresses referring to such code as
+  /// zero (BFD), a small positive integer (zero + relocation addend -- GOLD),
+  /// or -1/-2 (LLD). Try to filter out this debug info by comparing it to the
+  /// lowest code address in the module.
+  lldb::addr_t m_first_code_address = LLDB_INVALID_ADDRESS;
 };
 
 #endif // LLDB_SOURCE_PLUGINS_SYMBOLFILE_DWARF_SYMBOLFILEDWARF_H

lldb/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 //===-- SymbolFileDWARF.cpp -----------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
SymbolFileDWARF::SymbolFileDWARF(ObjectFileSP objfile_sp,
     : SymbolFile(std::move(objfile_sp)),
       UserID(0x7fffffff00000000), // Used by SymbolFileDWARFDebugMap to
                                   // when this class parses .o files to
                                   // contain the .o file index/ID
       m_debug_map_module_wp(), m_debug_map_symfile(nullptr),
       m_context(m_objfile_sp->GetModule()->GetSectionList(), dwo_section_list),
       m_fetched_external_modules(false),
       m_supports_DW_AT_APPLE_objc_complete_type(eLazyBoolCalculate) {}
 
 SymbolFileDWARF::~SymbolFileDWARF() {}
 
 static ConstString GetDWARFMachOSegmentName() {
   static ConstString g_dwarf_section_name("__DWARF");
   return g_dwarf_section_name;
 }
 
 UniqueDWARFASTTypeMap &SymbolFileDWARF::GetUniqueDWARFASTTypeMap() {
   SymbolFileDWARFDebugMap *debug_map_symfile = GetDebugMapSymfile();
   if (debug_map_symfile)
     return debug_map_symfile->GetUniqueDWARFASTTypeMap();
   else
if (debug_names.GetByteSize() > 0) {
       }
       LLDB_LOG_ERROR(log, index_or.takeError(),
                      "Unable to read .debug_names data: {0}");
     }
   }
 
   m_index =
       std::make_unique<ManualDWARFIndex>(*GetObjectFile()->GetModule(), *this);
+
+  const SectionList *section_list = m_objfile_sp->GetModule()->GetSectionList();
+  if (section_list)
+    InitializeFirstCodeAddress(*section_list);
+}
+
+void SymbolFileDWARF::InitializeFirstCodeAddress(
+    const lldb_private::SectionList &section_list) {
+  const uint32_t num_sections = section_list.GetSize();
+  for (uint32_t i = 0; i < num_sections; ++i) {
+    SectionSP section_sp(section_list.GetSectionAtIndex(i));
+    if (section_sp->GetChildren().GetSize() > 0) {
+      InitializeFirstCodeAddress(section_sp->GetChildren());
+    } else if (section_sp->GetType() == eSectionTypeCode) {
+      const addr_t section_file_address = section_sp->GetFileAddress();
+      if (m_first_code_address > section_file_address)
+        m_first_code_address = section_file_address;
+    }
+  }
 }
 
 bool SymbolFileDWARF::SupportedVersion(uint16_t version) {
   return version >= 2 && version <= 5;
 }
 
 uint32_t SymbolFileDWARF::CalculateAbilities() {
   uint32_t abilities = 0;
bool SymbolFileDWARF::ParseLineTable(CompileUnit &comp_unit) {
 
   // FIXME: Rather than parsing the whole line table and then copying it over
   // into LLDB, we should explore using a callback to populate the line table
   // while we parse to reduce memory usage.
   std::vector<std::unique_ptr<LineSequence>> sequences;
   // The Sequences view contains only valid line sequences. Don't iterate over
   // the Rows directly.
   for (const llvm::DWARFDebugLine::Sequence &seq : line_table->Sequences) {
+    // Ignore line sequences that do not start after the first code address.
+    // All addresses generated in a sequence are incremental so we only need
+    // to check the first one of the sequence. Check the comment at the
+    // m_first_code_address declaration for more details on this.
+    if (seq.LowPC < m_first_code_address)
+      continue;
     std::unique_ptr<LineSequence> sequence =
         LineTable::CreateLineSequenceContainer();
     for (unsigned idx = seq.FirstRowIndex; idx < seq.LastRowIndex; ++idx) {
       const llvm::DWARFDebugLine::Row &row = line_table->Rows[idx];
       LineTable::AppendLineEntryToSequence(
           sequence.get(), row.Address.Address, row.Line, row.Column, row.File,
           row.IsStmt, row.BasicBlock, row.PrologueEnd, row.EpilogueBegin,
           row.EndSequence);

lldb/test/Shell/SymbolFile/DWARF/line-entries-invalid-addresses.yaml

+# RUN: yaml2obj %s > %t
+# RUN: %lldb %t -b -o "image lookup -f main.cpp -l 2 -v" | FileCheck %s
+# CHECK: 1 match found in main.cpp:2 {{.*}}
+# CHECK: LineEntry: {{.*}}main.cpp:2:{{.*}}
+
+# int foo() {
+#     return 42;
+# }
+#
+# int main() {
+#     int x = foo();
+#     return x;
+# }
+# dwarfdump -debug-line:
+# Address            Line   Column File   ISA Discriminator Flags
+# ------------------ ------ ------ ------ --- ------------- -------------
+# 0x0000000100000f80      1      0      1   0             0  is_stmt
+# 0x0000000100000f84      2      5      1   0             0  is_stmt prologue_end
+# 0x0000000100000f8b      2      5      1   0             0  is_stmt end_sequence
+# 0x0000000100000f90      5      0      1   0             0  is_stmt
+# 0x0000000100000f90      5      0      1   0             0  is_stmt end_sequence
+# 0x000000000000000f      2     13      1   0             0  is_stmt prologue_end
+# 0x0000000000000014      2      9      1   0             0
+# 0x0000000000000017      3     12      1   0             0  is_stmt
+# 0x000000000000001d      3     12      1   0             0  end_sequence
+--- !mach-o
+FileHeader:
+  magic:           0xFEEDFACF
+  cputype:         0x01000007
+  cpusubtype:      0x00000003
+  filetype:        0x0000000A
+  ncmds:           7
+  sizeofcmds:      1400
+  flags:           0x00000000
+  reserved:        0x00000000
+LoadCommands:
+  - cmd:             LC_UUID
+    cmdsize:         24
+    uuid:            605D6BBF-4DB2-39F7-8068-F9BB3896DF0C
+  - cmd:             LC_BUILD_VERSION
+    cmdsize:         24
+    platform:        1
+    minos:           659200
+    sdk:             659206
+    ntools:          0
+  - cmd:             LC_SYMTAB
+    cmdsize:         24
+    symoff:          4096
+    nsyms:           3
+    stroff:          4144
+    strsize:         37
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         72
+    segname:         __PAGEZERO
+    vmaddr:          0
+    vmsize:          1
+    fileoff:         0
+    filesize:        0
+    maxprot:         0
+    initprot:        0
+    nsects:          0
+    flags:           0
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         232
+    segname:         __TEXT
+    vmaddr:          4294967296
+    vmsize:          4096
+    fileoff:         0
+    filesize:        0
+    maxprot:         5
+    initprot:        5
+    nsects:          2
+    flags:           0
+    Sections:
+      - sectname:        __text
+        segname:         __TEXT
+        addr:            0x0000000100000F80
+        size:            48
+        offset:          0x00000000
+        align:           4
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x80000400
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         CFFAEDFE07000001030000000A000000070000007805000000000000000000001B00000018000000605D6BBF4DB239F7
+      - sectname:        __unwind_info
+        segname:         __TEXT
+        addr:            0x0000000100000FB0
+        size:            72
+        offset:          0x00000000
+        align:           2
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+        content:         CFFAEDFE07000001030000000A000000070000007805000000000000000000001B00000018000000605D6BBF4DB239F78068F9BB3896DF0C320000001800000001000000000F0A00
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         72
+    segname:         __LINKEDIT
+    vmaddr:          4294971392
+    vmsize:          4096
+    fileoff:         4096
+    filesize:        85
+    maxprot:         1
+    initprot:        1
+    nsects:          0
+    flags:           0
+  - cmd:             LC_SEGMENT_64
+    cmdsize:         952
+    segname:         __DWARF
+    vmaddr:          4294975488
+    vmsize:          4096
+    fileoff:         8192
+    filesize:        839
+    maxprot:         7
+    initprot:        3
+    nsects:          4
+    flags:           0
+    Sections:
+      - sectname:        __debug_line
+        segname:         __DWARF
+        addr:            0x0000000100002000
+        size:            96
+        offset:          0x00002000
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+      - sectname:        __debug_info
+        segname:         __DWARF
+        addr:            0x00000001000020E9
+        size:            119
+        offset:          0x000020E9
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+      - sectname:        __debug_abbrev
+        segname:         __DWARF
+        addr:            0x0000000100002160
+        size:            90
+        offset:          0x00002160
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+      - sectname:        __debug_str
+        segname:         __DWARF
+        addr:            0x00000001000021BA
+        size:            130
+        offset:          0x000021BA
+        align:           0
+        reloff:          0x00000000
+        nreloc:          0
+        flags:           0x00000000
+        reserved1:       0x00000000
+        reserved2:       0x00000000
+        reserved3:       0x00000000
+LinkEditData:
+  NameList:
+    - n_strx:          2
+      n_type:          0x0F
+      n_sect:          1
+      n_desc:          0
+      n_value:         4294971264
+    - n_strx:          11
+      n_type:          0x0F
+      n_sect:          1
+      n_desc:          16
+      n_value:         4294967296
+    - n_strx:          31
+      n_type:          0x0F
+      n_sect:          1
+      n_desc:          0
+      n_value:         4294971280
+  StringTable:
+    - ''
+    - ''
+    - __Z3foov
+    - __mh_execute_header
+    - _main
+DWARF:
+  debug_str:
+    - ''
+    - 'Apple clang version 11.0.3 (clang-1103.0.32.62)'
+    - main.cpp
+    - '/Users/aadsm/toolchain_dev/external/llvm-project'
+    - _Z3foov
+    - foo
+    - main
+    - x
+    - int
+  debug_abbrev:
+    - ID:              0
+      Table:
+        - Code:            0x0000000000000001
+          Tag:             DW_TAG_compile_unit
+          Children:        DW_CHILDREN_yes
+          Attributes:
+            - Attribute:       DW_AT_producer
+              Form:            DW_FORM_strp
+            - Attribute:       DW_AT_language
+              Form:            DW_FORM_data2
+            - Attribute:       DW_AT_name
+              Form:            DW_FORM_strp
+            - Attribute:       DW_AT_stmt_list
+              Form:            DW_FORM_sec_offset
+            - Attribute:       DW_AT_comp_dir
+              Form:            DW_FORM_strp
+            - Attribute:       DW_AT_low_pc
+              Form:            DW_FORM_addr
+            - Attribute:       DW_AT_high_pc
+              Form:            DW_FORM_data4
+        - Code:            0x0000000000000002
+          Tag:             DW_TAG_subprogram
+          Children:        DW_CHILDREN_no
+          Attributes:
+            - Attribute:       DW_AT_low_pc
+              Form:            DW_FORM_addr
+            - Attribute:       DW_AT_high_pc
+              Form:            DW_FORM_data4
+            - Attribute:       DW_AT_frame_base
+              Form:            DW_FORM_exprloc
+            - Attribute:       DW_AT_linkage_name
+              Form:            DW_FORM_strp
+            - Attribute:       DW_AT_name
+              Form:            DW_FORM_strp
+            - Attribute:       DW_AT_decl_file
+              Form:            DW_FORM_data1
+            - Attribute:       DW_AT_decl_line
+              Form:            DW_FORM_data1
+            - Attribute:       DW_AT_type
+              Form:            DW_FORM_ref_addr
+            - Attribute:       DW_AT_external
+              Form:            DW_FORM_flag_present
+        - Code:            0x0000000000000003
+          Tag:             DW_TAG_subprogram
+          Children:        DW_CHILDREN_yes
+          Attributes:
+            - Attribute:       DW_AT_low_pc
+              Form:            DW_FORM_addr
+            - Attribute:       DW_AT_high_pc
+              Form:            DW_FORM_data4
+            - Attribute:       DW_AT_frame_base
+              Form:            DW_FORM_exprloc
+            - Attribute:       DW_AT_name
+              Form:            DW_FORM_strp
+            - Attribute:       DW_AT_decl_file
+              Form:            DW_FORM_data1
+            - Attribute:       DW_AT_decl_line
+              Form:            DW_FORM_data1
+            - Attribute:       DW_AT_type
+              Form:            DW_FORM_ref_addr
+            - Attribute:       DW_AT_external
+              Form:            DW_FORM_flag_present
+        - Code:            0x0000000000000004
+          Tag:             DW_TAG_variable
+          Children:        DW_CHILDREN_no
+          Attributes:
+            - Attribute:       DW_AT_location
+              Form:            DW_FORM_exprloc
+            - Attribute:       DW_AT_name
+              Form:            DW_FORM_strp
+            - Attribute:       DW_AT_decl_file
+              Form:            DW_FORM_data1
+            - Attribute:       DW_AT_decl_line
+              Form:            DW_FORM_data1
+            - Attribute:       DW_AT_type
+              Form:            DW_FORM_ref_addr
+        - Code:            0x0000000000000005
+          Tag:             DW_TAG_base_type
+          Children:        DW_CHILDREN_no
+          Attributes:
+            - Attribute:       DW_AT_name
+              Form:            DW_FORM_strp
+            - Attribute:       DW_AT_encoding
+              Form:            DW_FORM_data1
+            - Attribute:       DW_AT_byte_size
+              Form:            DW_FORM_data1
+  debug_info:
+    - Length:          0x0000000000000073
+      Version:         4
+      AbbrevTableID:   0
+      AbbrOffset:      0x0000000000000000
+      AddrSize:        8
+      Entries:
+        - AbbrCode:        0x00000001
+          Values:
+            - Value:           0x0000000000000001
+            - Value:           0x0000000000000004
+            - Value:           0x0000000000000031
+            - Value:           0x0000000000000000
+            - Value:           0x000000000000003A
+            - Value:           0x0000000100000F80
+            - Value:           0x0000000000000030
+        - AbbrCode:        0x00000002
+          Values:
+            - Value:           0x0000000100000F80
+            - Value:           0x000000000000000B
+            - Value:           0x0000000000000001
+              BlockData:       [ 0x56 ]
+            - Value:           0x000000000000006B
+            - Value:           0x0000000000000073
+            - Value:           0x0000000000000001
+            - Value:           0x0000000000000001
+            - Value:           0x000000000000006F
+            - Value:           0x0000000000000001
+        - AbbrCode:        0x00000003
+          Values:
+            - Value:           0x0000000100000F90
+            - Value:           0x0000000000000020
+            - Value:           0x0000000000000001
+              BlockData:       [ 0x56 ]
+            - Value:           0x0000000000000077
+            - Value:           0x0000000000000001
+            - Value:           0x0000000000000005
+            - Value:           0x000000000000006F
+            - Value:           0x0000000000000001
+        - AbbrCode:        0x00000004
+          Values:
+            - Value:           0x0000000000000002
+              BlockData:       [ 0x91, 0x78 ]
+            - Value:           0x000000000000007C
+            - Value:           0x0000000000000001
+            - Value:           0x0000000000000006
+            - Value:           0x000000000000006F
+        - AbbrCode:        0x00000000
+        - AbbrCode:        0x00000005
+          Values:
+            - Value:           0x000000000000007E
+            - Value:           0x0000000000000005
+            - Value:           0x0000000000000004
+        - AbbrCode:        0x00000000
+  debug_line:
+    - Length:          92
+      Version:         4
+      PrologueLength:  32
+      MinInstLength:   1
+      MaxOpsPerInst:   1
+      DefaultIsStmt:   1
+      LineBase:        251
+      LineRange:       14
+      OpcodeBase:      13
+      StandardOpcodeLengths: [ 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1 ]
+      IncludeDirs:     []
+      Files:
+        - Name:            main.cpp
+          DirIdx:          0
+          ModTime:         0
+          Length:          0
+      Opcodes:
+        - Opcode:          DW_LNS_extended_op
+          ExtLen:          9
+          SubOpcode:       DW_LNE_set_address
+          Data:            4294971264
+        - Opcode:          DW_LNS_copy
+          Data:            0
+        - Opcode:          DW_LNS_set_column
+          Data:            5
+        - Opcode:          DW_LNS_set_prologue_end
+          Data:            0
+        - Opcode:          0x4B
+          Data:            0
+        - Opcode:          DW_LNS_advance_pc
+          Data:            7
+        - Opcode:          DW_LNS_extended_op
+          ExtLen:          1
+          SubOpcode:       DW_LNE_end_sequence
+          Data:            0
+          # Sequence manually added (not produced by the source code)
+        - Opcode:          DW_LNS_extended_op
+          ExtLen:          9
+          SubOpcode:       DW_LNE_set_address
+          Data:            4294971280
+        - Opcode:          0x16
+          Data:            0
+        - Opcode:          DW_LNS_extended_op
+          ExtLen:          1
+          SubOpcode:       DW_LNE_end_sequence
+          Data:            0
+          # Sequence manually added (not produced by the source code)
+        - Opcode:          DW_LNS_set_column
+          Data:            13
+        - Opcode:          DW_LNS_set_prologue_end
+          Data:            0
+        - Opcode:          0xE5
+          Data:            0
+        - Opcode:          DW_LNS_set_column
+          Data:            9
+        - Opcode:          DW_LNS_negate_stmt
+          Data:            0
+        - Opcode:          0x58
+          Data:            0
+        - Opcode:          DW_LNS_set_column
+          Data:            12
+        - Opcode:          DW_LNS_negate_stmt
+          Data:            0
+        - Opcode:          0x3D
+          Data:            0
+        - Opcode:          DW_LNS_negate_stmt
+          Data:            0
+        - Opcode:          DW_LNS_advance_pc
+          Data:            6
+        - Opcode:          DW_LNS_extended_op
+          ExtLen:          1
+          SubOpcode:       DW_LNE_end_sequence
+          Data:            0
+...