[DWARF] Don't process .debug_info relocations for DWO Context

[ayermolo]

Summary

When we build with split dwarf in single mode the .o files that contain both "normal" debug sections and dwo sections, along with relocaiton sections for "normal" debug sections.
When we create DWARF context in DWARFObjInMemory we process relocations and store them in the map for .debug_info, etc section.
For DWO Context we also do it for non dwo dwarf sections. Which I believe is not necessary. This leads to a lot of memory being wasted. We observed 70GB extra memory being used.

I went with context sensitive approach, flag is passed in. I am not sure if it's always safe not to process relocations for regular debug sections if Obj contains .dwo sections.
If it is alternatvie might be just to scan, in constructor, sections and if there are .dwo sections not to process regular debug ones.

[dblaikie]

70GB seems like quite a bit - do you have a description of the scenario (ideally something reproducible - like "build clang at this revision with these flags and run these commands & the memory profile looks like this")? I'm guessing this is running llvm-symbolizer on a large Split DWARF input (without a DWP file, so using loose/separate .dwo files) and passing in many addresses to symbolize (forcing many of those .dwo files to be loaded)? I'd be curious to know exactly which data structures, etc,

Could this be tested - with, say, an invalid relocation or something, demonstrating that relocations are no longer applied? (I guess we never applied them to the .dwo sections, right? But we'd parse them for the non-dwo sections in the .dwo file (eg, when using split-dwarf=single?), so I'm not sure if there's any kind of invalidity we could put in the relocation section of the non-dwo sections - oh, I see we try to apply the relocations early, so maybe there is some invalidity that would expose this? not perfect, but maybe a little motivating/demonstrating.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1742

How come this tests both these properties? I guess there's some case where IsDWOContext is inadequate/isn't correct and the file extension test is needed? What's that case?

[ayermolo]

In D106624#2900158, @dblaikie wrote:

70GB seems like quite a bit - do you have a description of the scenario (ideally something reproducible - like "build clang at this revision with these flags and run these commands & the memory profile looks like this")? I'm guessing this is running llvm-symbolizer on a large Split DWARF input (without a DWP file, so using loose/separate .dwo files) and passing in many addresses to symbolize (forcing many of those .dwo files to be loaded)? I'd be curious to know exactly which data structures, etc,

Could this be tested - with, say, an invalid relocation or something, demonstrating that relocations are no longer applied? (I guess we never applied them to the .dwo sections, right? But we'd parse them for the non-dwo sections in the .dwo file (eg, when using split-dwarf=single?), so I'm not sure if there's any kind of invalidity we could put in the relocation section of the non-dwo sections - oh, I see we try to apply the relocations early, so maybe there is some invalidity that would expose this? not perfect, but maybe a little motivating/demonstrating.

Sorry, forgot to mention. This is regarding BOLT with -update-debug-sections turned on using it on an internal service build with -O2 mode and -g debug information. Without ThinLTO.
Right we are building it with -split-dwarf=single so the .dwo sections are in the .o file not in .dwo. Actually with -split-dwarf=split this problem would not manifest because it will only have .dwo sections.
I attached a screen shot with stack trace and memory consumption. Basically I am going through Skeleton CUs and creating DWARFUnits for non-skeleton CUs that are in .o files. This goes through getDWOContext and eventually calls DWARFObjInMemory. It doesn't know for what purpose it is invoked so it goes through all the debug sections. Including the regular one that are in .o file. Which we don't really care about I think since we are creating Context for DWO. If relocations for that exist then sure we should apply them (is that even a thing?), but for regular debug section, when creating context for DWO, I don't think it's necessary.
Thus a check for a flag and for .dwo. If it's true then we only care about .dwo sections.

[ayermolo]

After the fix. Both collected by @rafaelauler

[dblaikie]

If relocations for that exist then sure we should apply them (is that even a thing?)

No, relocations don't exist for dwo sections (if there are any relocations for dwo sections, that's a bug in the producer) - so skipping all relocation application for .dwo sections is fine/correct (could error out if there are relocation sections for dwo sections, though, if you like - but probably should do that in a separate patch).

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1742

Still curious about this.

[ayermolo]

In D106624#2901386, @dblaikie wrote:

If relocations for that exist then sure we should apply them (is that even a thing?)

No, relocations don't exist for dwo sections (if there are any relocations for dwo sections, that's a bug in the producer) - so skipping all relocation application for .dwo sections is fine/correct (could error out if there are relocation sections for dwo sections, though, if you like - but probably should do that in a separate patch).

This is related to your question about (IsDWOContext && !Name.contains(".dwo") check. Why I though both of them are needed. Looking at code on line 1776

else if (RelSecName == "debug_info.dwo")
          Map = &static_cast<DWARFSectionMap &>(
                     InfoDWOSections[*RelocatedSection])
                     .Relocs;

I thought there might be relocations for .debug_info.dwo so I structured a check in two parts flag plus ".dwo" so that if context is DWO and relocations for ".dwo" exist it will still process them.
Now I am confused. If relocations don't exist for dwo, why is that code there?
I traced it to https://reviews.llvm.org/D53907. Which seems to be DWARF V5 related.

If there are no relocations for .dwo then just checking IsDWOContext is enough, and !Name.contains(".dwo") is not necessary.

[dblaikie]

In D106624#2901747, @ayermolo wrote:

In D106624#2901386, @dblaikie wrote:

If relocations for that exist then sure we should apply them (is that even a thing?)

No, relocations don't exist for dwo sections (if there are any relocations for dwo sections, that's a bug in the producer) - so skipping all relocation application for .dwo sections is fine/correct (could error out if there are relocation sections for dwo sections, though, if you like - but probably should do that in a separate patch).

This is related to your question about (IsDWOContext && !Name.contains(".dwo") check. Why I though both of them are needed. Looking at code on line 1776

else if (RelSecName == "debug_info.dwo")
          Map = &static_cast<DWARFSectionMap &>(
                     InfoDWOSections[*RelocatedSection])
                     .Relocs;

I thought there might be relocations for .debug_info.dwo so I structured a check in two parts flag plus ".dwo" so that if context is DWO and relocations for ".dwo" exist it will still process them.
Now I am confused. If relocations don't exist for dwo, why is that code there?
I traced it to https://reviews.llvm.org/D53907. Which seems to be DWARF V5 related.

Yeah, I think that's just added for symmetry - probably copying what was done for .debug_types.dwo too (which I probably wrote) which also doesn't need relocation handling.

If there are no relocations for .dwo then just checking IsDWOContext is enough, and !Name.contains(".dwo") is not necessary.

Yeah, if you could remove that (& if you're willing, a separate patch to warn about relocations on .dwo sections) check, that'd be great!

Might be worth replacing the bool "IsDWO" parameters with an enum to make the callsites more legible rather than an anonymous "false" value? (might also be an opportunity to/worth creating a 3rd value for the enum - some kind of "indeterminate" state (& that one might be good to skip and warn on relocations in dwo sections) - this would come up when directly dumping a .dwo file, I think?)

[ayermolo]

Good point. Changed to ENUM. I left as two enums as I am not quite following the "interminate" remark.
Maybe this is related but running dwarfdump-header.s it fails because relocation section for .debug_info.dwo is being generated.
Looking at ELFWriter::writeObject looks like there was a code added to check the mode, but I haven't 100% internalized what all of it means. Do you have insights to shortcut it?
It was added in https://reviews.llvm.org/D47051

[ayermolo]

Also leaving it as one patch until all the changes are finalized. Will split later.

[ayermolo]

Digging a bit more in to a test and llvm-mc. I think modifying encoding of .debug_abbrev.dwo and .debug_info.dwo should do the trick...

[ayermolo]

Updatd failing test, added a test.

[dblaikie]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

390

This name might be a bit vague - and I don't think LLVM usually uses all-upper for enum constants. So maybe "SplitOrObjectSections" with "{Both, DWO, Object}"? I'm not really sure - open to better names.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1743–1747

Any thoughts/details on why one is an error and the other is a warning? (since they're about the same content, I think?)

Hmm, also it might not be invalid to encounter relocation sections in a dwo file in general - that's the split-dwarf=single case, isn't it? (ie: in split-dwarf=single, we'd be in this codiepath for ContextType::DWO, but the dwo file is really the .o file, so it'll have relocations for the non-.dwo sections - though they can/should be silently ignored, but they aren't an error/problem)

llvm/test/DebugInfo/X86/dwarfdump-header.s

24 ↗

(On Diff #362195)

The changes to this file could probably be committed separately in a standalone patch before this relocation handling patch, yeah? If so, please do that and rebase this patch on top.

llvm/test/DebugInfo/X86/dwarfdump-rela-dwo.s

2

This test seems a bit long (I see it's got structure types? That seems unnecessary for this purpose) - maybe a simple/single file with "extern int i; int i = 3;".

[ayermolo]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1743–1747

My original thinking was if consumer explicitly goes through the DWO context path there is expectation that DWO sections won't have any relocations, and should fail early, and warning might get ignored/missed. The "ALL" path is less critical. It's used for things such as llvm-dwarfdump where it's not necessary for it to fail and warning is more visible.
Re-thinking about it now, it doesn't really seem like a good argument. So maybe just keep it as a warning for both?
Also there is a bug. It should be:

if (RelocatedSection != Obj.section_end() && Name.contains(".dwo")) {
        if (Type == DWARFContext::ContextType::DWO)
          HandleError(createError(
              "Creating DWO Context with relocation section for " + Name));
        else if (Type == DWARFContext::ContextType::ALL)
          HandleWarning(createError("Relocation " + Name + " exists"));
      }

So dropping the difference:

if (RelocatedSection != Obj.section_end() && Name.contains(".dwo")) {
        if (Type == DWARFContext::ContextType::DWO || 
            Type == DWARFContext::ContextType::ALL)
            HandleWarning(createError("Relocation " + Name + " exists"));
      }

Or maybe just to simplify the whole thing and remove enum and

if (RelocatedSection != Obj.section_end() && Name.contains(".dwo"))
            HandleWarning(createError("Relocation " + Name + " exists"));

If we are removing the code that handles the relocations for dwo sections, and establish that this is not a valid scenario, then there is no real reason to distinguish what context this is. Since even if they are present we will print a warning, and output won't be correct.

[dblaikie]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1743–1747

If we are removing the code that handles the relocations for dwo sections, and establish that this is not a valid scenario, then there is no real reason to distinguish what context this is. Since even if they are present we will print a warning, and output won't be correct.

Almost - but I think you want to skip /all/ relocations when you're in a DWO context, right? (for split-dwarf=single - where you're parsing the .dwo file (which is really the .o file) and don't want to handle all the non-dwo sections, etc because you know its only the dwo parts that are relevant) so you'd still need the context to implement that, I think?

[ayermolo]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1743–1747

Derp moment on my part. The enum is still necessary.

[dblaikie]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

390

Ping on this. (and maybe "NonSplit" rather than "Object" would be more clear - but finding a more specific name than "ContextType" is probably the important part of making this more self-descriptive/less vague)

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1743–1747

OK, so coming back to this code - seems like we could error any time we see relocations for .dwo sections though - without checking the "ContextType". But, separately, we should check the "ContextType" and if it's DWO, no relocations should be processed, yeah? (that latter part seems to be the code a few lines lower, at 1749 \/)

So this warning/error code could be simplified to:

if (RelocatedSection != Obj.section_end() && Name.contains(".dwo"))
  HandleWarning(createError("Unexpected relocations for dwo section " + Name));

Something like that?

llvm/test/DebugInfo/X86/dwarfdump-rela-dwo.s

2

Ping on this - still seems a bit long/convoluted.

[ayermolo]

Sorry was waiting for modified test to land before circling back.
Updated warning, and enum (more in inline comments).

[ayermolo]

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

390

How about this?
Thinking is what we really care about is whether to process or not relocations. With warning being consolidated to one case (dwo relocations are present), doesn't seem we need to distinguish between various cases.

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1743–1747

Yep, yep, exactly.

llvm/test/DebugInfo/X86/dwarfdump-rela-dwo.s

2

OK, let me see if I can modify this/regenerate a new one.

[ayermolo]

Updated the test.

[ayermolo]

lint

[dblaikie]

Sounds good - thanks for your patience!

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

390

While I think the new name is more descriptive - it still feels a bit confusing for readers at call sites - still feels like the caller passing "ProcessDebugRelocations::Ignore" would benefit from a comment explaining why they should be ignored here (& maybe even similarly at the other call sites passing "Process" - be nice if it were a defaulted argument, but the other mix of defaulted arguments means it's hard to actually use the default (because other callers want to specify some subset of the arguments)...

Hmm, but I keep coming up with issues with all the other ideas for naming/API design I have here, so let's just go with this one. It's not used prolifically and could be renamed/improved later without significant cost.

[ayermolo]

In D106624#2917931, @dblaikie wrote:

Sounds good - thanks for your patience!

Thank you for review, will commit.

[MaskRay]

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

1742

This may fire for .text.dwo .rodata.dwo and create some difficulty for PE/COFF when it adds DWO support (D152785). I created D153602 to adjust the condition.

Also, ends_with would be slightly better.

llvm/include/llvm/DebugInfo/DWARF/DWARFContext.h

public:
   const MCRegisterInfo *getRegisterInfo() const { return RegInfo.get(); }
 
   function_ref<void(Error)> getRecoverableErrorHandler() {
     return RecoverableErrorHandler;
   }
 
   function_ref<void(Error)> getWarningHandler() { return WarningHandler; }
 
+  enum class ProcessDebugRelocations { Process, Ignore };
+
   static std::unique_ptr<DWARFContext>
-  create(const object::ObjectFile &Obj, const LoadedObjectInfo *L = nullptr,
-         std::string DWPName = "",
+  create(const object::ObjectFile &Obj,
+         ProcessDebugRelocations RelocAction = ProcessDebugRelocations::Process,
+         const LoadedObjectInfo *L = nullptr, std::string DWPName = "",
          std::function<void(Error)> RecoverableErrorHandler =
              WithColor::defaultErrorHandler,
          std::function<void(Error)> WarningHandler =
              WithColor::defaultWarningHandler);
 
   static std::unique_ptr<DWARFContext>
   create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
          uint8_t AddrSize, bool isLittleEndian = sys::IsLittleEndianHost,

llvm/lib/DebugInfo/DWARF/DWARFContext.cpp

DWARFContext::getDWOContext(StringRef AbsolutePath) {
   if (!Obj) {
     // TODO: Actually report errors helpfully.
     consumeError(Obj.takeError());
     return nullptr;
   }
 
   auto S = std::make_shared<DWOFile>();
   S->File = std::move(Obj.get());
-  S->Context = DWARFContext::create(*S->File.getBinary());
+  S->Context = DWARFContext::create(*S->File.getBinary(),
+                                    ProcessDebugRelocations::Ignore);
   *Entry = S;
   auto *Ctxt = S->Context.get();
   return std::shared_ptr<DWARFContext>(std::move(S), Ctxt);
 }
 
 static Error createError(const Twine &Reason, llvm::Error E) {
   return make_error<StringError>(Reason + toString(std::move(E)),
                                  inconvertibleErrorCode());
for (const auto &SecIt : Sections) {
         InfoDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
       else if (SecIt.first() == "debug_types")
         TypesSections[SectionRef()].Data = SecIt.second->getBuffer();
       else if (SecIt.first() == "debug_types.dwo")
         TypesDWOSections[SectionRef()].Data = SecIt.second->getBuffer();
     }
   }
   DWARFObjInMemory(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
-                   function_ref<void(Error)> HandleError, function_ref<void(Error)> HandleWarning )
+                   function_ref<void(Error)> HandleError,
+                   function_ref<void(Error)> HandleWarning,
+                   DWARFContext::ProcessDebugRelocations RelocAction)
       : IsLittleEndian(Obj.isLittleEndian()),
         AddressSize(Obj.getBytesInAddress()), FileName(Obj.getFileName()),
         Obj(&Obj) {
 
     StringMap<unsigned> SectionAmountMap;
     for (const SectionRef &Section : Obj.sections()) {
       StringRef Name;
       if (auto NameOrErr = Section.getName())
for (const SectionRef &Section : Obj.sections()) {
                          .Case("debug_types.dwo", &TypesDWOSections)
                          .Default(nullptr)) {
         // Find debug_info and debug_types data by section rather than name as
         // there are multiple, comdat grouped, of these sections.
         DWARFSectionMap &S = (*Sections)[Section];
         S.Data = Data;
       }
 
-      if (RelocatedSection == Obj.section_end())
+      if (RelocatedSection != Obj.section_end() && Name.contains(".dwo"))
+        HandleWarning(
+            createError("Unexpected relocations for dwo section " + Name));
+
+      if (RelocatedSection == Obj.section_end() ||
+          (RelocAction == DWARFContext::ProcessDebugRelocations::Ignore))
         continue;
 
       StringRef RelSecName;
       if (auto NameOrErr = RelocatedSection->getName())
         RelSecName = *NameOrErr;
       else
         consumeError(NameOrErr.takeError());
 
       // If the section we're relocating was relocated already by the JIT,
for (const SectionRef &Section : Obj.sections()) {
       DWARFSectionMap *Sec = mapNameToDWARFSection(RelSecName);
       RelocAddrMap *Map = Sec ? &Sec->Relocs : nullptr;
       if (!Map) {
         // Find debug_info and debug_types relocs by section rather than name
         // as there are multiple, comdat grouped, of these sections.
         if (RelSecName == "debug_info")
           Map = &static_cast<DWARFSectionMap &>(InfoSections[*RelocatedSection])
                      .Relocs;
-        else if (RelSecName == "debug_info.dwo")
-          Map = &static_cast<DWARFSectionMap &>(
-                     InfoDWOSections[*RelocatedSection])
-                     .Relocs;
         else if (RelSecName == "debug_types")
           Map =
               &static_cast<DWARFSectionMap &>(TypesSections[*RelocatedSection])
                    .Relocs;
-        else if (RelSecName == "debug_types.dwo")
-          Map = &static_cast<DWARFSectionMap &>(
-                     TypesDWOSections[*RelocatedSection])
-                     .Relocs;
         else
           continue;
       }
 
       if (Section.relocation_begin() == Section.relocation_end())
         continue;
 
       // Symbol to [address, section index] cache mapping.
void forEachTypesSections(
       function_ref<void(const DWARFSection &)> F) const override {
     for (auto &P : TypesSections)
       F(P.second);
   }
 };
 } // namespace
 
 std::unique_ptr<DWARFContext>
-DWARFContext::create(const object::ObjectFile &Obj, const LoadedObjectInfo *L,
-                     std::string DWPName,
+DWARFContext::create(const object::ObjectFile &Obj,
+                     ProcessDebugRelocations RelocAction,
+                     const LoadedObjectInfo *L, std::string DWPName,
                      std::function<void(Error)> RecoverableErrorHandler,
                      std::function<void(Error)> WarningHandler) {
-  auto DObj =
-      std::make_unique<DWARFObjInMemory>(Obj, L, RecoverableErrorHandler, WarningHandler);
+  auto DObj = std::make_unique<DWARFObjInMemory>(
+      Obj, L, RecoverableErrorHandler, WarningHandler, RelocAction);
   return std::make_unique<DWARFContext>(std::move(DObj), std::move(DWPName),
                                         RecoverableErrorHandler,
                                         WarningHandler);
 }
 
 std::unique_ptr<DWARFContext>
 DWARFContext::create(const StringMap<std::unique_ptr<MemoryBuffer>> &Sections,
                      uint8_t AddrSize, bool isLittleEndian,

llvm/lib/DebugInfo/Symbolize/Symbolize.cpp

if (!EC && DebugInfo != nullptr && !PDBFileName.empty()) {
         Modules.emplace(ModuleName, std::unique_ptr<SymbolizableModule>());
         // Return along the PDB filename to provide more context
         return createFileError(PDBFileName, std::move(Err));
       }
       Context.reset(new PDBContext(*CoffObject, std::move(Session)));
     }
   }
   if (!Context)
-    Context = DWARFContext::create(*Objects.second, nullptr, Opts.DWPName);
+    Context = DWARFContext::create(
+        *Objects.second, DWARFContext::ProcessDebugRelocations::Process,
+        nullptr, Opts.DWPName);
   return createModuleInfo(Objects.first, std::move(Context), ModuleName);
 }
 
 Expected<SymbolizableModule *>
 LLVMSymbolizer::getOrCreateModuleInfo(const ObjectFile &Obj) {
   StringRef ObjName = Obj.getFileName();
   auto I = Modules.find(ObjName);
   if (I != Modules.end())

llvm/test/DebugInfo/X86/dwarfdump-rela-dwo.s

+# Test objective to verify warning is printed if DWO secton has relocations.
+#
+# RUN: llvm-mc -triple x86_64-unknown-linux %s -filetype=obj -o %t.o
+# RUN: llvm-dwarfdump --debug-info %t.o | FileCheck %s
+# RUN: llvm-dwarfdump --debug-info %t.o 2> %t.txt
+# RUN: cat %t.txt | FileCheck %s --check-prefix=PART2
+
+        .section .debug_str.dwo,"MSe",@progbits,1
+.dwo_producer:
+        .asciz "Handmade DWO producer"
+.dwo_CU_5:
+        .asciz "V5_dwo_compile_unit"
+
+        .section  .debug_str_offsets.dwo,"e",@progbits
+        .long Lstr_offsets_end-Lstr_offsets_start                              # Length of String Offsets Set
+        Lstr_offsets_start:
+  .short  5
+  .short  0
+  .long .dwo_producer-.debug_str.dwo
+  .long .dwo_CU_5-.debug_str.dwo
+        Lstr_offsets_end:
+
+# And a .dwo copy for the .dwo sections.
+        .section .debug_abbrev.dwo,"e",@progbits
+        .byte 0x01  # Abbrev code
+        .byte 0x11  # DW_TAG_compile_unit
+        .byte 0x00  # DW_CHILDREN_no
+        .byte 0x25  # DW_AT_producer
+        .byte 0x0e  # DW_FORM_strp
+        .byte 0x03  # DW_AT_name
+        .byte 0x25  # DW_FORM_strx1
+        .byte 0x00  # EOM(1)
+        .byte 0x00  # EOM(2)
+
+        .section .debug_info.dwo,"e",@progbits
+# CHECK-LABEL: .debug_info.dwo
+
+# DWARF v5 split CU header.
+        .long  CU_split_5_end-CU_split_5_version # Length of Unit
+CU_split_5_version:
+        .short 5                # DWARF version number
+        .byte 5                 # DWARF Unit Type
+        .byte 8                 # Address Size (in bytes)
+        .long 0 # Offset Into Abbrev. Section
+        .quad 0x5a              # DWO ID
+# The split compile-unit DIE, with DW_AT_producer, DW_AT_name, DW_AT_stmt_list.
+        .byte 1
+        .long .dwo_producer
+        .byte 1
+        .byte 0 # NULL
+CU_split_5_end:
+
+# CHECK: 0x00000000: Compile Unit: length = 0x00000017, format = DWARF32, version = 0x0005, unit_type = DW_UT_split_compile, abbr_offset = 0x0000, addr_size = 0x08, DWO_id = 0x000000000000005a (next unit at 0x0000001b)
+# CHECK: 0x00000014: DW_TAG_compile_unit
+# CHECK-NEXT: DW_AT_producer  ("Handmade DWO producer")
+# CHECK-NEXT: DW_AT_name  ("V5_dwo_compile_unit")
+# PART2: warning: Unexpected relocations for dwo section rela.debug_info.dwo

llvm/tools/llvm-dwarfdump/llvm-dwarfdump.cpp

static bool handleBuffer(StringRef Filename, MemoryBufferRef Buffer,
 
   bool Result = true;
   auto RecoverableErrorHandler = [&](Error E) {
     Result = false;
     WithColor::defaultErrorHandler(std::move(E));
   };
   if (auto *Obj = dyn_cast<ObjectFile>(BinOrErr->get())) {
     if (filterArch(*Obj)) {
-      std::unique_ptr<DWARFContext> DICtx =
-          DWARFContext::create(*Obj, nullptr, "", RecoverableErrorHandler);
+      std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(
+          *Obj, DWARFContext::ProcessDebugRelocations::Process, nullptr, "",
+          RecoverableErrorHandler);
       if (!HandleObj(*Obj, *DICtx, Filename, OS))
         Result = false;
     }
   } else if (auto *Fat = dyn_cast<MachOUniversalBinary>(BinOrErr->get()))
     for (auto &ObjForArch : Fat->objects()) {
       std::string ObjName =
           (Filename + "(" + ObjForArch.getArchFlagName() + ")").str();
       if (auto MachOOrErr = ObjForArch.getAsObjectFile()) {
         auto &Obj = **MachOOrErr;
         if (filterArch(Obj)) {
-          std::unique_ptr<DWARFContext> DICtx =
-              DWARFContext::create(Obj, nullptr, "", RecoverableErrorHandler);
+          std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(
+              Obj, DWARFContext::ProcessDebugRelocations::Process, nullptr, "",
+              RecoverableErrorHandler);
           if (!HandleObj(Obj, *DICtx, ObjName, OS))
             Result = false;
         }
         continue;
       } else
         consumeError(MachOOrErr.takeError());
       if (auto ArchiveOrErr = ObjForArch.getAsArchive()) {
         error(ObjName, ArchiveOrErr.takeError());

llvm/tools/llvm-readobj/DwarfCFIEHPrinter.h

void PrinterContext<ELFT>::printEHFrame(const Elf_Shdr *EHFrameShdr) const {
   W.indent();
 
   Expected<ArrayRef<uint8_t>> DataOrErr =
       ObjF.getELFFile().getSectionContents(*EHFrameShdr);
   if (!DataOrErr)
     reportError(DataOrErr.takeError(), ObjF.getFileName());
 
   // Construct DWARFDataExtractor to handle relocations ("PC Begin" fields).
-  std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(ObjF, nullptr);
+  std::unique_ptr<DWARFContext> DICtx = DWARFContext::create(
+      ObjF, DWARFContext::ProcessDebugRelocations::Process, nullptr);
   DWARFDataExtractor DE(DICtx->getDWARFObj(),
                         DICtx->getDWARFObj().getEHFrameSection(),
                         ELFT::TargetEndianness == support::endianness::little,
                         ELFT::Is64Bits ? 8 : 4);
   DWARFDebugFrame EHFrame(Triple::ArchType(ObjF.getArch()), /*IsEH=*/true,
                           /*EHFrameAddress=*/Address);
   if (Error E = EHFrame.parse(DE))
     reportError(std::move(E), ObjF.getFileName());

llvm/tools/llvm-rtdyld/llvm-rtdyld.cpp

if (LoadObjects) {
 
       if (UseDebugObj) {
         DebugObj = LoadedObjInfo->getObjectForDebug(Obj);
         SymbolObj = DebugObj.getBinary();
         LoadedObjInfo.reset();
       }
     }
 
-    std::unique_ptr<DIContext> Context =
-        DWARFContext::create(*SymbolObj, LoadedObjInfo.get());
+    std::unique_ptr<DIContext> Context = DWARFContext::create(
+        *SymbolObj, DWARFContext::ProcessDebugRelocations::Process,
+        LoadedObjInfo.get());
 
     std::vector<std::pair<SymbolRef, uint64_t>> SymAddr =
         object::computeSymbolSizes(*SymbolObj);
 
     // Use symbol info to iterate functions in the object.
     for (const auto &P : SymAddr) {
       object::SymbolRef Sym = P.first;
       Expected<SymbolRef::Type> TypeOrErr = Sym.getType();

llvm/unittests/DebugInfo/DWARF/DWARFDebugInfoTest.cpp

TEST(DWARFDebugInfo, TestErrorReporting) {
   AP->OutStreamer->emitBytes("0");
 
   MemoryBufferRef FileBuffer(DG->generate(), "dwarf");
   auto Obj = object::ObjectFile::createObjectFile(FileBuffer);
   EXPECT_TRUE((bool)Obj);
 
   // DWARFContext parses whole file and finds the two errors we expect.
   int Errors = 0;
-  std::unique_ptr<DWARFContext> Ctx1 =
-      DWARFContext::create(**Obj, nullptr, "", [&](Error E) {
+  std::unique_ptr<DWARFContext> Ctx1 = DWARFContext::create(
+      **Obj, DWARFContext::ProcessDebugRelocations::Process, nullptr, "",
+      [&](Error E) {
         ++Errors;
         consumeError(std::move(E));
       });
   EXPECT_TRUE(Errors == 2);
 }
 
 TEST(DWARFDebugInfo, TestDwarfVerifyCURangesIncomplete) {
   // Create a single compile unit with a single function. The compile