Fix bug in .eh_frame/.debug_frame PC offset calculation for DW_EH_PE_pcrel

[aorlov]

Summary

To calculate a correct PC offset we need to apply the target address from the eh_frame.

This fixes the following bugs:
https://bugs.llvm.org/show_bug.cgi?id=27249
https://bugs.llvm.org/show_bug.cgi?id=46414

[MaskRay]

LG. The stored address is used as EHFrameAddress in llvm/lib/DebugInfo/DWARF/DWARFDebugFrame.cpp

1134           // Decode the LSDA if the CIE augmentation string said we should.                                                                                                                                                       
1135           if (Cie->getLSDAPointerEncoding() != DW_EH_PE_omit) {
1136             LSDAAddress = Data.getEncodedPointer(                                                                                                                                                                                 
1137                 &Offset, Cie->getLSDAPointerEncoding(),
1138                 EHFrameAddress ? Offset + EHFrameAddress : 0);
1139           }

llvm/include/llvm/DebugInfo/DWARF/DWARFSection.h

18

= 0

lld/test/ELF/eh-frame-hdr-augmentation.s

 // REQUIRES: x86
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 // RUN: ld.lld --hash-style=sysv --eh-frame-hdr %t.o -o %t -shared
 // RUN: llvm-objdump --dwarf=frames %t | FileCheck %s
 
 // CHECK: .eh_frame contents:
 
 // CHECK:      00000000 0000001c 00000000 CIE
 // CHECK-NEXT:   Format:                DWARF32
 // CHECK-NEXT:   Version:                       1
 // CHECK-NEXT:   Augmentation:             "zPLR"
 // CHECK-NEXT:   Code alignment factor: 1
 // CHECK-NEXT:   Data alignment factor: -8
 // CHECK-NEXT:   Return address column: 16
-// CHECK-NEXT:   Personality Address: 0000000000001029
+// CHECK-NEXT:   Personality Address: 000000000000127c
 // CHECK-NEXT:   Augmentation data:
 
 // CHECK:      DW_CFA_def_cfa:  reg7 +8
 // CHECK-NEXT: DW_CFA_offset:   reg16 -8
 // CHECK-NEXT: DW_CFA_nop:
 // CHECK-NEXT: DW_CFA_nop:
 
 /// FIXME Handle relocation correctly
-// CHECK:      00000020 00000014 00000024 FDE cie=00000000 pc=0000103c...0000103c
+// CHECK:      00000020 00000014 00000024 FDE cie=00000000 pc=0000127c...0000127c
 // CHECK-NEXT:   Format:       DWARF32
-// CHECK-NEXT:   LSDA Address: 000000000000100b
+// CHECK-NEXT:   LSDA Address: 000000000000127c
 // CHECK-NEXT:   DW_CFA_nop:
 // CHECK-NEXT:   DW_CFA_nop:
 // CHECK-NEXT:   DW_CFA_nop:
 
         .cfi_startproc
         .cfi_personality 0x9b, g
         .cfi_lsda 0x1b, h
         .cfi_endproc

llvm/include/llvm/DebugInfo/DWARF/DWARFSection.h

 #define LLVM_DEBUGINFO_DWARF_DWARFSECTION_H
 
 #include "llvm/ADT/StringRef.h"
 
 namespace llvm {
 
 struct DWARFSection {
   StringRef Data;
+  uint64_t Address = 0;
 };
 
 struct SectionName {
   StringRef Name;
   bool IsNameUnique;
 };
 
 } // end namespace llvm
 
 #endif // LLVM_DEBUGINFO_DWARF_DWARFSECTION_H

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

const DWARFDebugAranges *DWARFContext::getDebugAranges() {
   Aranges->generate(this);
   return Aranges.get();
 }
 
 Expected<const DWARFDebugFrame *> DWARFContext::getDebugFrame() {
   if (DebugFrame)
     return DebugFrame.get();
 
+  const DWARFSection &DS = DObj->getFrameSection();
+
   // There's a "bug" in the DWARFv3 standard with respect to the target address
   // size within debug frame sections. While DWARF is supposed to be independent
   // of its container, FDEs have fields with size being "target address size",
   // which isn't specified in DWARF in general. It's only specified for CUs, but
   // .eh_frame can appear without a .debug_info section. Follow the example of
   // other tools (libdwarf) and extract this from the container (ObjectFile
   // provides this information). This problem is fixed in DWARFv4
   // See this dwarf-discuss discussion for more details:
   // http://lists.dwarfstd.org/htdig.cgi/dwarf-discuss-dwarfstd.org/2011-December/001173.html
-  DWARFDataExtractor debugFrameData(*DObj, DObj->getFrameSection(),
-                                    isLittleEndian(), DObj->getAddressSize());
-  auto DF = std::make_unique<DWARFDebugFrame>(getArch(), /*IsEH=*/false);
-  if (Error E = DF->parse(debugFrameData))
+  DWARFDataExtractor DebugFrameData(*DObj, DS, isLittleEndian(),
+                                    DObj->getAddressSize());
+  auto DF =
+      std::make_unique<DWARFDebugFrame>(getArch(), /*IsEH=*/false, DS.Address);
+  if (Error E = DF->parse(DebugFrameData))
     return std::move(E);
 
   DebugFrame.swap(DF);
   return DebugFrame.get();
 }
 
 Expected<const DWARFDebugFrame *> DWARFContext::getEHFrame() {
   if (EHFrame)
     return EHFrame.get();
 
-  DWARFDataExtractor debugFrameData(*DObj, DObj->getEHFrameSection(),
-                                    isLittleEndian(), DObj->getAddressSize());
-
-  auto DF = std::make_unique<DWARFDebugFrame>(getArch(), /*IsEH=*/true);
-  if (Error E = DF->parse(debugFrameData))
+  const DWARFSection &DS = DObj->getEHFrameSection();
+  DWARFDataExtractor DebugFrameData(*DObj, DS, isLittleEndian(),
+                                    DObj->getAddressSize());
+
+  auto DF =
+      std::make_unique<DWARFDebugFrame>(getArch(), /*IsEH=*/true, DS.Address);
+  if (Error E = DF->parse(DebugFrameData))
     return std::move(E);
   DebugFrame.swap(DF);
   return DebugFrame.get();
 }
 
 const DWARFDebugMacro *DWARFContext::getDebugMacro() {
   if (!Macro)
     Macro = parseMacroOrMacinfo(MacroSection);
for (const SectionRef &Section : Obj.sections()) {
       // names.
       Name = Obj.mapDebugSectionName(Name);
 
       if (StringRef *SectionData = mapSectionToMember(Name)) {
         *SectionData = Data;
         if (Name == "debug_ranges") {
           // FIXME: Use the other dwo range section when we emit it.
           RangesDWOSection.Data = Data;
+        } else if (Name == "debug_frame" || Name == "eh_frame") {
+          if (DWARFSection *S = mapNameToDWARFSection(Name))
+            S->Address = Section.getAddress();
         }
       } else if (InfoSectionMap *Sections =
                      StringSwitch<InfoSectionMap *>(Name)
                          .Case("debug_info", &InfoSections)
                          .Case("debug_info.dwo", &InfoDWOSections)
                          .Case("debug_types", &TypesSections)
                          .Case("debug_types.dwo", &TypesDWOSections)
                          .Default(nullptr)) {

llvm/test/tools/llvm-dwarfdump/X86/debug_frame_offset.test

 RUN: llc -filetype=obj %p/../../dsymutil/Inputs/frame-dw2.ll -o - \
 RUN:   | llvm-dwarfdump -debug-frame=0x00000014 - | FileCheck %s
 CHECK: .debug_frame contents:
 CHECK-NEXT: 00000014 00000014 00000000 FDE cie=00000000 pc=00000000...0000001d
 CHECK-NEXT:   Format:       DWARF32
 CHECK-NEXT:   DW_CFA_advance_loc: 1
 CHECK-NOT: pc
 
 RUN: llvm-dwarfdump %p/../../dsymutil/Inputs/basic1.macho.x86_64.o \
 RUN:   -eh-frame=0x00000018 | FileCheck %s --check-prefix=EH
 EH: .eh_frame contents:
-EH-NEXT: 00000018 00000024 0000001c FDE cie=00000000 pc=fffffffffffffd20...fffffffffffffd44
+EH-NEXT: 00000018 00000024 0000001c FDE cie=00000000 pc=00000000...00000024
 EH-NEXT:   Format:       DWARF32
 EH-NEXT:   DW_CFA_advance_loc: 1
 EH-NOT: pc
 EH-NOT: CIE

llvm/test/tools/llvm-objdump/MachO/eh_frame-arm64.test

 # RUN: llvm-objdump --dwarf=frames %p/Inputs/eh_frame.macho-arm64 2>/dev/null | FileCheck %s
 
 # CHECK: .eh_frame contents:
 
 # CHECK: 00000000 00000010 00000000 CIE
 # CHECK:   Version:               1
 # CHECK:   Augmentation:          "zR"
 # CHECK:   Code alignment factor: 1
 # CHECK:   Data alignment factor: -8
 # CHECK:   Return address column: 30
 # CHECK:   Augmentation data:     10
 
 # CHECK:   DW_CFA_def_cfa: reg31 +0
 
-# CHECK: 00000014 00000020 00000018 FDE cie=00000000 pc=00000000...00000020
+# CHECK: 00000014 00000020 00000018 FDE cie=00000000 pc=00000050...00000070
 # CHECK:   DW_CFA_advance_loc: 8
 # CHECK:   DW_CFA_def_cfa_offset: +16
 # CHECK:   DW_CFA_offset: reg30 -8
 # CHECK:   DW_CFA_offset: reg29 -16
 # CHECK:   DW_CFA_nop:
 # CHECK:   DW_CFA_nop:
 # CHECK:   DW_CFA_nop:
 # CHECK:   DW_CFA_nop: