[Symbolizer] Implement pc element in symbolizing filter.

[mysterymath]

Summary

Implements the pc element for the symbolizing filter, including it's
"ra" and "pc" modes. Return addresses ("ra") are adjusted by
decrementing one. By default, {{{pc}}} elements are assumed to point to
precise code ("pc") locations. Backtrace elements will adopt the
opposite convention.

Along the way, some minor refactors of value printing and colorization.

[mysterymath]

Change PC location information from angle brackets to brackets to avoid
conflicting with C++ template arguments.

[phosek]

llvm/include/llvm/DebugInfo/Symbolize/MarkupFilter.h

74–83

Nit: it's more common in LLVM to use capitalized names for enums, see https://llvm.org/docs/CodingStandards.html#name-types-functions-variables-and-enumerators-properly

[mysterymath]

Correct enum naming convention.
Handle default PC type out of band.
Fix data test.

llvm/include/llvm/DebugInfo/Symbolize/MarkupFilter.h

74–83

I remember looking this up because I wasn't sure, then apparently I promptly forgot about what I found. Done.

[peter.smith]

Implementation looks good to me. One quick question to clarify my understanding.

llvm/lib/DebugInfo/Symbolize/MarkupFilter.cpp

255

Just wanted to check my understanding of whether it is important when subtracting from Addr to land on the start of an instruction? My guess is not, as it would be difficult on a variable length instruction set.

Reading the documentation for ra in the backtrace section:
the symbolizing filter will subtract one byte or one instruction length from the actual return address for the call site
It looks like from the test case

4: e8 00 00 00 00         callq   0x9 <first+0x9> // Line 4
9: 5d                            popq    %rbp                 // Line 5

That address 9 - 1 is within the callq instruction and not the start yet it still displays line 4 so it all looks OK.

On AArch64 it would be possible to subtract 4 as all instructions are 4-bytes, but no need if subtracting 1 will work.

[mysterymath]

llvm/lib/DebugInfo/Symbolize/MarkupFilter.cpp

255

Yep, that's the standard hack, since the Symbolizer will return the same source location for any byte within the call. It's decidedly gross, but piping through per-target instruction length information is probably gross-er.

[mysterymath]

Add explanatory comment for ra adjustment.

[peter.smith]

Thanks for the explanation. LGTM. May be worth waiting a day or so to see if anyone else on the review has any further comments.

[mysterymath]

Use adjustAddr function declared in header.

[mysterymath]

Fix test on Windows.

[thakis]

Looks like this breaks tests on Windows: http://45.33.8.238/win/64016/step_11.txt

Please take a look, and revert for now if it takes a while to fix.

[mysterymath]

In D131115#3707494, @thakis wrote:

Looks like this breaks tests on Windows: http://45.33.8.238/win/64016/step_11.txt

Please take a look, and revert for now if it takes a while to fix.

Sorry, I had just fixed this, but it got dropped due to a git snafu on my end. Should be fixed by 0d6cf1e8b5

llvm/docs/CommandGuide/llvm-symbolizer.rst

 
 .. option:: --filter-markup
 
   Reads from standard input, converts contained
   :doc:`Symbolizer Markup </SymbolizerMarkupFormat>` into human-readable form,
   and prints the results to standard output. The following markup elements are
   not yet supported:
 
-  * ``{{pc}}``
   * ``{{bt}}``
   * ``{{hexdict}}``
   * ``{{dumpfile}}``
 
 .. _llvm-symbolizer-opt-f:
 
 .. option:: --functions [=<none|short|linkage>], -f
 

llvm/docs/SymbolizerMarkupFormat.rst

``{{{symbol:%s}}}``
   recommended that this markup element be used to identify a symbol name so that
   it can be presented distinctively.
 
   Examples::
 
     {{{symbol:_ZN7Mangled4NameEv}}}
     {{{symbol:foobar}}}
 
-``{{{pc:%p}}}``, ``{{{pc:%p:ra}}}``, ``{{{pc:%p:pc}}}`` [#not_yet_implemented]_
+``{{{pc:%p}}}``, ``{{{pc:%p:ra}}}``, ``{{{pc:%p:pc}}}``
 
   Here ``%p`` is the memory address of a code location. It might be presented as a
   function name and source location. The second two forms distinguish the kind of
   code location, as described in detail for bt elements below.
 
   Examples::
 
     {{{pc:0x12345678}}}

llvm/include/llvm/DebugInfo/Symbolize/MarkupFilter.h

private:
   // An informational module line currently being constructed. As many mmap
   // elements as possible are folded into one ModuleInfo line.
   struct ModuleInfoLine {
     const Module *Mod;
 
     SmallVector<const MMap *> MMaps = {};
   };
 
+  // The semantics of a possible program counter value.
+  enum class PCType {
+    // The address is a return address and must be adjusted to point to the call
+    // itself.
+    ReturnAddress,
+    // The address is the precise location in the code and needs no adjustment.
+    PreciseCode,
+  };
+
   bool tryContextualElement(const MarkupNode &Node,
                             const SmallVector<MarkupNode> &DeferredNodes);
   bool tryMMap(const MarkupNode &Element,
                const SmallVector<MarkupNode> &DeferredNodes);
   bool tryReset(const MarkupNode &Element,
                 const SmallVector<MarkupNode> &DeferredNodes);
   bool tryModule(const MarkupNode &Element,
                  const SmallVector<MarkupNode> &DeferredNodes);
 
   void beginModuleInfoLine(const Module *M);
   void endAnyModuleInfoLine();
 
   void filterNode(const MarkupNode &Node);
 
   bool tryPresentation(const MarkupNode &Node);
   bool trySymbol(const MarkupNode &Node);
+  bool tryPC(const MarkupNode &Node);
   bool tryData(const MarkupNode &Node);
 
   bool trySGR(const MarkupNode &Node);
 
   void highlight();
   void highlightValue();
   void restoreColor();
   void resetColor();
 
+  void printRawElement(const MarkupNode &Element);
+  void printValue(Twine Value);
+
   Optional<Module> parseModule(const MarkupNode &Element) const;
   Optional<MMap> parseMMap(const MarkupNode &Element) const;
 
   Optional<uint64_t> parseAddr(StringRef Str) const;
   Optional<uint64_t> parseModuleID(StringRef Str) const;
   Optional<uint64_t> parseSize(StringRef Str) const;
   Optional<SmallVector<uint8_t>> parseBuildID(StringRef Str) const;
   Optional<std::string> parseMode(StringRef Str) const;
+  Optional<PCType> parsePCType(StringRef Str) const;
 
   bool checkTag(const MarkupNode &Node) const;
   bool checkNumFields(const MarkupNode &Element, size_t Size) const;
   bool checkNumFieldsAtLeast(const MarkupNode &Element, size_t Size) const;
+  bool checkNumFieldsAtMost(const MarkupNode &Element, size_t Size) const;
 
   void reportTypeError(StringRef Str, StringRef TypeName) const;
   void reportLocation(StringRef::iterator Loc) const;
 
   const MMap *getOverlappingMMap(const MMap &Map) const;
   const MMap *getContainingMMap(uint64_t Addr) const;
 
+  uint64_t adjustAddr(uint64_t Addr, PCType Type) const;
+
   StringRef lineEnding() const;
 
   raw_ostream &OS;
   LLVMSymbolizer &Symbolizer;
   const bool ColorsEnabled;
 
   MarkupParser Parser;
 

llvm/lib/DebugInfo/Symbolize/MarkupFilter.cpp

 //===----------------------------------------------------------------------===//
 
 #include "llvm/DebugInfo/Symbolize/MarkupFilter.h"
 
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringSwitch.h"
+#include "llvm/DebugInfo/DIContext.h"
 #include "llvm/DebugInfo/Symbolize/Markup.h"
 #include "llvm/DebugInfo/Symbolize/Symbolize.h"
 #include "llvm/Debuginfod/Debuginfod.h"
 #include "llvm/Demangle/Demangle.h"
 #include "llvm/Object/ObjectFile.h"
 #include "llvm/Support/Error.h"
 #include "llvm/Support/FormatVariadic.h"
 #include "llvm/Support/WithColor.h"
bool MarkupFilter::tryModule(const MarkupNode &Node,
   }
   Module &Module = *Res.first->second;
 
   endAnyModuleInfoLine();
   for (const MarkupNode &Node : DeferredNodes)
     filterNode(Node);
   beginModuleInfoLine(&Module);
   OS << "; BuildID=";
-  highlightValue();
-  OS << toHex(Module.BuildID, /*LowerCase=*/true);
-  highlight();
+  printValue(toHex(Module.BuildID, /*LowerCase=*/true));
   return true;
 }
 
 void MarkupFilter::beginModuleInfoLine(const Module *M) {
   highlight();
   OS << "[[[ELF module";
-  highlightValue();
-  OS << formatv(" #{0:x} \"{1}\"", M->ID, M->Name);
-  highlight();
+  printValue(formatv(" #{0:x} ", M->ID));
+  OS << '"';
+  printValue(M->Name);
+  OS << '"';
   MIL = ModuleInfoLine{M};
 }
 
 void MarkupFilter::endAnyModuleInfoLine() {
   if (!MIL)
     return;
   llvm::stable_sort(MIL->MMaps, [](const MMap *A, const MMap *B) {
     return A->Addr < B->Addr;
   });
   for (const MMap *M : MIL->MMaps) {
     OS << (M == MIL->MMaps.front() ? ' ' : ',');
-    highlightValue();
-    OS << formatv("[{0:x}-{1:x}]", M->Addr, M->Addr + M->Size - 1);
-    highlight();
-    OS << '(';
-    highlightValue();
-    OS << M->Mode;
-    highlight();
+    OS << '[';
+    printValue(formatv("{0:x}", M->Addr));
+    OS << '-';
+    printValue(formatv("{0:x}", M->Addr + M->Size - 1));
+    OS << "](";
+    printValue(M->Mode);
     OS << ')';
   }
   OS << "]]]" << lineEnding();
   restoreColor();
   MIL.reset();
 }
 
 // Handle a node that is known not to be a contextual element.
 void MarkupFilter::filterNode(const MarkupNode &Node) {
   if (!checkTag(Node))
     return;
   if (tryPresentation(Node))
     return;
   if (trySGR(Node))
     return;
 
   OS << Node.Text;
 }
 
 bool MarkupFilter::tryPresentation(const MarkupNode &Node) {
   if (trySymbol(Node))
     return true;
+  if (tryPC(Node))
+    return true;
   return tryData(Node);
 }
 
 bool MarkupFilter::trySymbol(const MarkupNode &Node) {
   if (Node.Tag != "symbol")
     return false;
   if (!checkNumFields(Node, 1))
     return true;
 
   highlight();
   OS << llvm::demangle(Node.Fields.front().str());
   restoreColor();
   return true;
 }
 
-bool MarkupFilter::tryData(const MarkupNode &Node) {
-  if (Node.Tag != "data")
+bool MarkupFilter::tryPC(const MarkupNode &Node) {
+  if (Node.Tag != "pc")
     return false;
-  if (!checkNumFields(Node, 1))
+  if (!checkNumFieldsAtLeast(Node, 1))
+    return true;
+  if (!checkNumFieldsAtMost(Node, 2))
     return true;
+
   Optional<uint64_t> Addr = parseAddr(Node.Fields[0]);
   if (!Addr)
     return true;
 
-  const auto PrintRaw = [&]() {
-    highlight();
-    OS << "[[[data:";
-    highlightValue();
-    OS << "0x" << toHex(*Addr, /*LowerCase=*/true);
-    highlight();
-    OS << "]]]\n";
-    restoreColor();
-  };
+  // PC addresses that aren't part of a backtrace are assumed to be precise code
+  // locations.
+  PCType Type = PCType::PreciseCode;
+  if (Node.Fields.size() == 2) {
+    Optional<PCType> ParsedType = parsePCType(Node.Fields[1]);
+    if (!ParsedType)
+      return true;
+    Type = *ParsedType;
+  }
+  *Addr = adjustAddr(*Addr, Type);
+
+  const MMap *MMap = getContainingMMap(*Addr);
+  if (!MMap) {
+    WithColor::error() << "no mmap covers address\n";
+    reportLocation(Node.Fields[0].begin());
+    printRawElement(Node);
+    return true;
+  }
+
+  Expected<DILineInfo> LI = Symbolizer.symbolizeCode(
+      MMap->Mod->BuildID, {MMap->getModuleRelativeAddr(*Addr)});
+  if (!LI) {
+    WithColor::defaultErrorHandler(LI.takeError());
+    printRawElement(Node);
+    return true;
+  }
+  if (LI->FileName == DILineInfo::BadString &&
+      LI->FunctionName == DILineInfo::BadString && LI->Line == 0) {
+    printRawElement(Node);
+    return true;
+  }
+
+  printValue(LI->FunctionName);
+  OS << '[';
+  printValue(LI->FileName);
+  OS << ':';
+  printValue(Twine(LI->Line));
+  OS << ']';
+  return true;
+}
+
+bool MarkupFilter::tryData(const MarkupNode &Node) {
+  if (Node.Tag != "data")
+    return false;
+  if (!checkNumFields(Node, 1))
+    return true;
+  Optional<uint64_t> Addr = parseAddr(Node.Fields[0]);
+  if (!Addr)
+    return true;
 
   const MMap *MMap = getContainingMMap(*Addr);
   if (!MMap) {
     WithColor::error() << "no mmap covers address\n";
     reportLocation(Node.Fields[0].begin());
-    PrintRaw();
+    printRawElement(Node);
     return true;
   }
 
   Expected<DIGlobal> Symbol = Symbolizer.symbolizeData(
       MMap->Mod->BuildID, {MMap->getModuleRelativeAddr(*Addr)});
   if (!Symbol) {
     WithColor::defaultErrorHandler(Symbol.takeError());
-    PrintRaw();
+    printRawElement(Node);
     return true;
   }
 
   highlight();
   OS << Symbol->Name;
   restoreColor();
   return true;
 }
void MarkupFilter::resetColor() {
   if (!Color && !Bold)
     return;
   Color.reset();
   Bold = false;
   if (ColorsEnabled)
     OS.resetColor();
 }
 
+void MarkupFilter::printRawElement(const MarkupNode &Element) {
+  highlight();
+  OS << "[[[";
+  printValue(Element.Tag);
+  for (StringRef Field : Element.Fields) {
+    OS << ':';
+    printValue(Field);
+  }
+  OS << "]]]";
+  restoreColor();
+}
+
+void MarkupFilter::printValue(Twine Value) {
+  highlightValue();
+  OS << Value;
+  highlight();
+}
+
 // This macro helps reduce the amount of indirection done through Optional
 // below, since the usual case upon returning a None Optional is to return None.
 #define ASSIGN_OR_RETURN_NONE(TYPE, NAME, EXPR)                                \
   auto NAME##Opt = (EXPR);                                                     \
   if (!NAME##Opt)                                                              \
     return None;                                                               \
   TYPE NAME = std::move(*NAME##Opt)
 
if (!Remainder.empty()) {
     reportTypeError(Str, "mode");
     return None;
   }
 
   // Normalize the mode.
   return Str.lower();
 }
 
+Optional<MarkupFilter::PCType> MarkupFilter::parsePCType(StringRef Str) const {
+  Optional<MarkupFilter::PCType> Type =
+      StringSwitch<Optional<MarkupFilter::PCType>>(Str)
+          .Case("ra", MarkupFilter::PCType::ReturnAddress)
+          .Case("pc", MarkupFilter::PCType::PreciseCode)
+          .Default(None);
+  if (!Type)
+    reportTypeError(Str, "PC type");
+  return Type;
+}
+
 bool MarkupFilter::checkTag(const MarkupNode &Node) const {
   if (any_of(Node.Tag, [](char C) { return C < 'a' || C > 'z'; })) {
     WithColor::error(errs()) << "tags must be all lowercase characters\n";
     reportLocation(Node.Tag.begin());
     return false;
   }
   return true;
 }
WithColor::error(errs())
         << "expected at least " << Size << " field(s); found "
         << Element.Fields.size() << "\n";
     reportLocation(Element.Tag.end());
     return false;
   }
   return true;
 }
 
+bool MarkupFilter::checkNumFieldsAtMost(const MarkupNode &Element,
+                                        size_t Size) const {
+  if (Element.Fields.size() > Size) {
+    WithColor::error(errs())
+        << "expected at most " << Size << " field(s); found "
+        << Element.Fields.size() << "\n";
+    reportLocation(Element.Tag.end());
+    return false;
+  }
+  return true;
+}
+
 void MarkupFilter::reportTypeError(StringRef Str, StringRef TypeName) const {
   WithColor::error(errs()) << "expected " << TypeName << "; found '" << Str
                            << "'\n";
   reportLocation(Str.begin());
 }
 
 // Prints two lines that point out the given location in the current Line using
 // a caret. The iterator must be within the bounds of the most recent line
const MarkupFilter::MMap *MarkupFilter::getContainingMMap(uint64_t Addr) const {
 
   // The previous mmap is the last one starting < Addr.
   if (I == MMaps.begin())
     return nullptr;
   --I;
   return I->second.contains(Addr) ? &I->second : nullptr;
 }
 
+uint64_t MarkupFilter::adjustAddr(uint64_t Addr, PCType Type) const {
+  // Decrementing return addresses by one moves them into the call instruction.
+  // The address doesn't have to be the start of the call instruction, just some
+  // byte on the inside. Subtracting one avoids needing detailed instruction
+  // length information here.
+  return Type == MarkupFilter::PCType::ReturnAddress ? Addr - 1 : Addr;
+}
+
 StringRef MarkupFilter::lineEnding() const {
   return Line.endswith("\r\n") ? "\r\n" : "\n";
 }
 
 bool MarkupFilter::MMap::contains(uint64_t Addr) const {
   return this->Addr <= Addr && Addr < this->Addr + Size;
 }
 
 // Returns the module-relative address for a given virtual address.
 uint64_t MarkupFilter::MMap::getModuleRelativeAddr(uint64_t Addr) const {
   return Addr - this->Addr + ModuleRelativeAddr;
 }

llvm/test/DebugInfo/symbolize-filter-markup-data.test

 REQUIRES: x86-registered-target
 RUN: split-file %s %t
 RUN: mkdir -p %t/.build-id/ab
 RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %t/asm.s \
 RUN:   -o %t/.build-id/ab/cdef.debug
 RUN: llvm-symbolizer --debug-file-directory=%t --filter-markup < %t/input \
 RUN:   > %t.output 2> %t.err
 RUN: FileCheck %s --input-file=%t.output --match-full-lines \
 RUN:   --implicit-check-not {{.}}
 RUN: FileCheck %s --check-prefix=ERR --input-file=%t.err --match-full-lines
 
 CHECK: [[BEGIN:\[{3}]]ELF module #0x0 "a.o"; BuildID=abcdef [0x0-0x4](r),[0x10-0x11](r)[[END:\]{3}]]
 CHECK: long long byte
 CHECK: long byte
-CHECK: [[BEGIN]]data:0x05[[END]]
+CHECK: [[BEGIN]]data:0x5[[END]]
 
 ERR: error: expected 1 field(s); found 0
 ERR: error: no mmap covers address
 
 ;--- input
 {{{module:0:a.o:elf:abcdef}}}
 {{{mmap:0:5:load:0:r:0}}}
 {{{mmap:0x10:2:load:0:r:0x3}}}

llvm/test/DebugInfo/symbolize-filter-markup-pc.test

+REQUIRES: x86-registered-target
+RUN: split-file %s %t
+RUN: mkdir -p %t/.build-id/ab
+RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %t/asm.s \
+RUN:   -o %t/.build-id/ab/cdef.debug
+RUN: llvm-symbolizer --debug-file-directory=%t --filter-markup < %t/input \
+RUN:   > %t.output 2> %t.err
+RUN: FileCheck %s --input-file=%t.output --match-full-lines \
+RUN:   --implicit-check-not {{.}}
+RUN: FileCheck %s --check-prefix=ERR --input-file=%t.err --match-full-lines
+
+CHECK: [[BEGIN:\[{3}]]ELF module #0x0 "a.o"; BuildID=abcdef [0x0-0xff](r)[[END:\]{3}]]
+CHECK: first[/dir/tmp.c:3]
+CHECK: first[/dir/tmp.c:5]
+CHECK: first[/dir/tmp.c:4]
+CHECK: first[/dir/tmp.c:5]
+CHECK: [[BEGIN]]pc:0xff[[END]]
+CHECK: [[BEGIN]]pc:0x100[[END]]
+
+ERR: error: expected at least 1 field(s); found 0
+ERR: error: no mmap covers address
+ERR: error: expected PC type; found ''
+ERR: error: expected at most 2 field(s); found 3
+
+;--- input
+{{{module:0:a.o:elf:abcdef}}}
+{{{mmap:0:256:load:0:r:0}}}
+{{{pc:0}}}
+{{{pc:0x9}}}
+{{{pc:0x9:ra}}}
+{{{pc:0x9:pc}}}
+{{{pc:0xff}}}
+
+{{{pc}}}
+{{{pc:0x100}}}
+{{{pc:0x9:}}}
+{{{pc:0x9:pc:}}}
+;--- asm.s
+  .text
+  .file "tmp.c"
+  .globl  first                           # -- Begin function first
+  .p2align  4, 0x90
+  .type first,@function
+first:                                  # @first
+.Lfunc_begin0:
+  .file 1 "/dir" "tmp.c"
+  .loc  1 3 0                           # tmp.c:3:0
+  .cfi_startproc
+# %bb.0:
+  pushq %rbp
+  .cfi_def_cfa_offset 16
+  .cfi_offset %rbp, -16
+  movq  %rsp, %rbp
+  .cfi_def_cfa_register %rbp
+.Ltmp0:
+  .loc  1 4 3 prologue_end              # tmp.c:4:3
+  callq second
+  .loc  1 5 1                           # tmp.c:5:1
+  popq  %rbp
+  .cfi_def_cfa %rsp, 8
+  retq
+.Ltmp1:
+.Lfunc_end0:
+  .size first, .Lfunc_end0-first
+  .cfi_endproc
+                                        # -- End function
+  .globl  second                          # -- Begin function second
+  .p2align  4, 0x90
+  .type second,@function
+second:                                 # @second
+.Lfunc_begin1:
+  .loc  1 7 0                           # tmp.c:7:0
+  .cfi_startproc
+# %bb.0:
+  pushq %rbp
+  .cfi_def_cfa_offset 16
+  .cfi_offset %rbp, -16
+  movq  %rsp, %rbp
+  .cfi_def_cfa_register %rbp
+.Ltmp2:
+  .loc  1 8 3 prologue_end              # tmp.c:8:3
+  callq first
+  .loc  1 9 1                           # tmp.c:9:1
+  popq  %rbp
+  .cfi_def_cfa %rsp, 8
+  retq
+.Ltmp3:
+.Lfunc_end1:
+  .size second, .Lfunc_end1-second
+  .cfi_endproc
+                                        # -- End function
+  .section  .debug_abbrev,"",@progbits
+  .byte 1                               # Abbreviation Code
+  .byte 17                              # DW_TAG_compile_unit
+  .byte 1                               # DW_CHILDREN_yes
+  .byte 37                              # DW_AT_producer
+  .byte 14                              # DW_FORM_strp
+  .byte 19                              # DW_AT_language
+  .byte 5                               # DW_FORM_data2
+  .byte 3                               # DW_AT_name
+  .byte 14                              # DW_FORM_strp
+  .byte 16                              # DW_AT_stmt_list
+  .byte 23                              # DW_FORM_sec_offset
+  .byte 27                              # DW_AT_comp_dir
+  .byte 14                              # DW_FORM_strp
+  .byte 17                              # DW_AT_low_pc
+  .byte 1                               # DW_FORM_addr
+  .byte 18                              # DW_AT_high_pc
+  .byte 6                               # DW_FORM_data4
+  .byte 0                               # EOM(1)
+  .byte 0                               # EOM(2)
+  .byte 2                               # Abbreviation Code
+  .byte 46                              # DW_TAG_subprogram
+  .byte 0                               # DW_CHILDREN_no
+  .byte 17                              # DW_AT_low_pc
+  .byte 1                               # DW_FORM_addr
+  .byte 18                              # DW_AT_high_pc
+  .byte 6                               # DW_FORM_data4
+  .byte 64                              # DW_AT_frame_base
+  .byte 24                              # DW_FORM_exprloc
+  .byte 3                               # DW_AT_name
+  .byte 14                              # DW_FORM_strp
+  .byte 58                              # DW_AT_decl_file
+  .byte 11                              # DW_FORM_data1
+  .byte 59                              # DW_AT_decl_line
+  .byte 11                              # DW_FORM_data1
+  .byte 39                              # DW_AT_prototyped
+  .byte 25                              # DW_FORM_flag_present
+  .byte 63                              # DW_AT_external
+  .byte 25                              # DW_FORM_flag_present
+  .byte 0                               # EOM(1)
+  .byte 0                               # EOM(2)
+  .byte 0                               # EOM(3)
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Ldebug_info_end0-.Ldebug_info_start0 # Length of Unit
+.Ldebug_info_start0:
+  .short  4                               # DWARF version number
+  .long .debug_abbrev                   # Offset Into Abbrev. Section
+  .byte 8                               # Address Size (in bytes)
+  .byte 1                               # Abbrev [1] 0xb:0x4a DW_TAG_compile_unit
+  .long .Linfo_string0                  # DW_AT_producer
+  .short  12                              # DW_AT_language
+  .long .Linfo_string1                  # DW_AT_name
+  .long .Lline_table_start0             # DW_AT_stmt_list
+  .long .Linfo_string2                  # DW_AT_comp_dir
+  .quad .Lfunc_begin0                   # DW_AT_low_pc
+  .long .Lfunc_end1-.Lfunc_begin0       # DW_AT_high_pc
+  .byte 2                               # Abbrev [2] 0x2a:0x15 DW_TAG_subprogram
+  .quad .Lfunc_begin0                   # DW_AT_low_pc
+  .long .Lfunc_end0-.Lfunc_begin0       # DW_AT_high_pc
+  .byte 1                               # DW_AT_frame_base
+  .byte 86
+  .long .Linfo_string3                  # DW_AT_name
+  .byte 1                               # DW_AT_decl_file
+  .byte 3                               # DW_AT_decl_line
+                                        # DW_AT_prototyped
+                                        # DW_AT_external
+  .byte 2                               # Abbrev [2] 0x3f:0x15 DW_TAG_subprogram
+  .quad .Lfunc_begin1                   # DW_AT_low_pc
+  .long .Lfunc_end1-.Lfunc_begin1       # DW_AT_high_pc
+  .byte 1                               # DW_AT_frame_base
+  .byte 86
+  .long .Linfo_string4                  # DW_AT_name
+  .byte 1                               # DW_AT_decl_file
+  .byte 7                               # DW_AT_decl_line
+                                        # DW_AT_prototyped
+                                        # DW_AT_external
+  .byte 0                               # End Of Children Mark
+.Ldebug_info_end0:
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_string0:
+  .asciz  "clang" # string offset=0
+.Linfo_string1:
+  .asciz  "tmp.c"                         # string offset=30
+.Linfo_string2:
+  .asciz  "/dir" # string offset=36
+.Linfo_string3:
+  .asciz  "first"                         # string offset=85
+.Linfo_string4:
+  .asciz  "second"                        # string offset=91
+  .ident  "clang"
+  .section  ".note.GNU-stack","",@progbits
+  .addrsig
+  .addrsig_sym first
+  .addrsig_sym second
+  .section  .debug_line,"",@progbits
+.Lline_table_start0: