[debug_loc] Fix typo in DWARFExpression constructor

[labath]

Summary

The positions of the DwarfVersion and AddressSize arguments were
reversed, which caused parsing for dwarf opcodes which contained
address-size-dependent operands (such as DW_OP_addr). Amusingly enough,
none of the address-size asserts fired, as dwarf version was always 4,
which is a valid address size.

I ran into this when constructing weird inputs for the DWARF verifier. I
I add a test case as hand-written dwarf -- I am not sure how to trigger
this differently, as having a DW_OP_addr inside a location list is a
fairly non-standard thing to do.

Fixing this error exposed a bug in the debug_loc.dwo parser, which was
always being constructed with an address size of 0. I fix that as well
by following the pattern in the non-dwo parser of picking up the address
size from the first compile unit (which is technically not correct, but
probably good enough in practice).

[aprantl]

lib/DebugInfo/DWARF/DWARFContext.cpp

689 ↗

(On Diff #141157)

LLVM always prefers full sentences:

// Assume all compile units have the same address byte size.

lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

36 ↗

(On Diff #141157)

Ouch.

[JDevlieghere]

Wow... great thing you caught this.

[labath]

lib/DebugInfo/DWARF/DWARFContext.cpp

689 ↗

(On Diff #141157)

I thought you might say that. :)
I will fix also the place where I copied this from.

llvm/trunk/lib/DebugInfo/DWARF/DWARFContext.cpp

const DWARFDebugAbbrev *DWARFContext::getDebugAbbrevDWO() {
   return AbbrevDWO.get();
 }
 
 const DWARFDebugLoc *DWARFContext::getDebugLoc() {
   if (Loc)
     return Loc.get();
 
   Loc.reset(new DWARFDebugLoc);
-  // assume all compile units have the same address byte size
+  // Assume all compile units have the same address byte size.
   if (getNumCompileUnits()) {
     DWARFDataExtractor LocData(*DObj, DObj->getLocSection(), isLittleEndian(),
                                getCompileUnitAtIndex(0)->getAddressByteSize());
     Loc->parse(LocData);
   }
   return Loc.get();
 }
 
 const DWARFDebugLocDWO *DWARFContext::getDebugLocDWO() {
   if (LocDWO)
     return LocDWO.get();
 
-  DataExtractor LocData(DObj->getLocDWOSection().Data, isLittleEndian(), 0);
   LocDWO.reset(new DWARFDebugLocDWO());
+  // Assume all compile units have the same address byte size.
+  if (getNumCompileUnits()) {
+    DataExtractor LocData(DObj->getLocDWOSection().Data, isLittleEndian(),
+                          getCompileUnitAtIndex(0)->getAddressByteSize());
     LocDWO->parse(LocData);
+  }
   return LocDWO.get();
 }
 
 const DWARFDebugAranges *DWARFContext::getDebugAranges() {
   if (Aranges)
     return Aranges.get();
 
   Aranges.reset(new DWARFDebugAranges());

llvm/trunk/lib/DebugInfo/DWARF/DWARFDebugLoc.cpp

 // expression that LLVM doesn't produce. Guessing the wrong version means we
 // won't be able to pretty print expressions in DWARF2 binaries produced by
 // non-LLVM tools.
 static void dumpExpression(raw_ostream &OS, ArrayRef<char> Data,
                            bool IsLittleEndian, unsigned AddressSize,
                            const MCRegisterInfo *MRI) {
   DWARFDataExtractor Extractor(StringRef(Data.data(), Data.size()),
                                IsLittleEndian, AddressSize);
-  DWARFExpression(Extractor, AddressSize, dwarf::DWARF_VERSION).print(OS, MRI);
+  DWARFExpression(Extractor, dwarf::DWARF_VERSION, AddressSize).print(OS, MRI);
 }
 
 void DWARFDebugLoc::LocationList::dump(raw_ostream &OS, bool IsLittleEndian,
                                        unsigned AddressSize,
                                        const MCRegisterInfo *MRI,
                                        unsigned Indent) const {
   for (const Entry &E : Entries) {
     OS << '\n';

llvm/trunk/test/tools/llvm-dwarfdump/X86/debug_loc-OP_addr.s

+# RUN: llvm-mc -triple x86_64-pc-linux %s -filetype=obj | llvm-dwarfdump - | FileCheck %s
+#
+# CHECK: DW_TAG_variable
+# CHECK-NEXT: DW_AT_name ("a")
+# CHECK-NEXT: DW_AT_location
+# CHECK-NEXT: [0x0000000000000000,  0x0000000000000001): DW_OP_addr 0xdeadbeefbaadf00d
+
+  .section  .debug_str,"MS",@progbits,1
+.Linfo_producer:
+  .asciz  "hand-written DWARF"
+.Lname_a:
+  .asciz  "a"
+
+  .section  .debug_loc,"",@progbits
+.Ldebug_loc0:
+  .quad 0
+  .quad 1
+  .short  .Lloc0_end-.Lloc0_start # Loc expr size
+.Lloc0_start:
+  .byte 3                       # DW_OP_addr
+        .quad 0xdeadbeefbaadf00d
+.Lloc0_end:
+  .quad 0
+  .quad 0
+
+  .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 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 5                       # Abbreviation Code
+  .byte 52                      # DW_TAG_variable
+  .byte 0                       # DW_CHILDREN_no
+  .byte 3                       # DW_AT_name
+  .byte 14                      # DW_FORM_strp
+  .byte 2                       # DW_AT_location
+  .byte 23                      # DW_FORM_sec_offset
+  .byte 0                       # EOM(1)
+  .byte 0                       # EOM(2)
+  .byte 0                       # EOM(3)
+
+  .section  .debug_info,"",@progbits
+.Lcu_begin0:
+  .long .Lcu_end0-.Lcu_start0   # Length of Unit
+.Lcu_start0:
+  .short  4                       # DWARF version number
+  .long .debug_abbrev           # Offset Into Abbrev. Section
+  .byte 8                       # Address Size (in bytes)
+  .byte 1                       # Abbrev [1] DW_TAG_compile_unit
+  .long .Linfo_producer         # DW_AT_producer
+  .byte 5                       # Abbrev [5] DW_TAG_variable
+  .long .Lname_a                # DW_AT_name
+  .long .Ldebug_loc0            # DW_AT_location
+  .byte 0                       # End Of Children Mark
+.Lcu_end0: