DebugInfo: Add a CU metadata attribute for use of DWARF ranges base address specifiers

[dblaikie]

Summary

Ranges base address specifiers can save a lot of object size in
relocation records especially in optimized builds.

For an optimized self-host build of Clang with split DWARF and debug
info compression in object files, but uncompressed debug info in the
executable, this change produces about 18% smaller object files and 6%
larger executable.

While it would've been nice to turn this on by default, gold's 32 bit
gdb-index support crashes on this input & I don't think there's any
perfect heuristic to implement solely in LLVM that would suffice - so
we'll need a flag one way or another (also possible people might want to
aggressively optimized for executable size that contains debug info
(even with compression this would still come at some cost to executable
size)) - so let's plumb it through.

I'm open to suggestions on naming - I suppose having "debug" in the name of the metadata attribute is a bit redundant - of course it's debug related when it's there. How fully qualified should the name be? "useRangesBaseAddressSpecifiers" is a bit of a mouthful. "rangesBaseAddresses: true" ? or just "baseAddress: true" baseAddresses?

[aprantl]

lib/Bitcode/Reader/MetadataLoader.cpp

1399 ↗

(On Diff #173093)

I guess we don't need an extra upgrade test because there are already plenty older format CUs in .bc files that also exercise this?

test/DebugInfo/X86/range_reloc.ll

120 ↗

(On Diff #173093)

Are those necessary?

[dblaikie]

Remove unnecessary attributes and add test input description

[dblaikie]

lib/Bitcode/Reader/MetadataLoader.cpp

1399 ↗

(On Diff #173093)

Yeah, that was my thinking!

test/DebugInfo/X86/range_reloc.ll

120 ↗

(On Diff #173093)

Oh, nah - removed them and updated the test to have some comments about the original source & what it's testing with the different pieces.

[JDevlieghere]

Is this going to be used for anything other than ranges? If not I'd slightly prefer rangesBaseAddress over debugBaseAddress.

[dblaikie]

In D54242#1291956, @JDevlieghere wrote:

Is this going to be used for anything other than ranges? If not I'd slightly prefer rangesBaseAddress over debugBaseAddress.

Yeah, seems reasonable. (I'll hold off on actually making the naming change until I get a sense everyone's roughly on the same page)

It's /possible/ we would want to configure the use of certain forms (including base address specifiers) in debug_loclists.dwo in v4 mode (this change already only applies to v4 - in v5 we use rnglists & expect a conformant implementation that handles all the v5 loclist entry kinds) - seems GDB only supports the forms we already use in v4, even though there are more efficient forms we could use (& it only supports the efficient forms in v5 standard loclists - not the forms we use in v4... ). But probably best to just move to v5 there, rather than trying to get v4 support in GDB to handle it, then have a conditional flag for users who have the fixed GDB or don't, etc. See this commit for some details about that fiasco: http://llvm.org/viewvc/llvm-project?view=revision&revision=345326

[echristo]

Naming sounds ok to me :)

[dblaikie]

Settled on renaming the DICompileUnit attribute from debugBaseAddress to rangesBaseAddress (since 'debug' is redundant, and this is really specific to ranges base address specifiers).

[aprantl]

llvm/trunk/lib/Bitcode/Reader/MetadataLoader.cpp

1399

@dblaikie Let me know if I'm just confused, but I don't think this works. The check on line 1383 rejects any records with a size of 20.
Incidentally, serialization of the baseAddress flag isn't being tested in test/Assembler/dicompileunit.ll.

[dblaikie]

llvm/trunk/lib/Bitcode/Reader/MetadataLoader.cpp

1399

Thanks! Addressed in c51b45e32ef7f35c11891f60871aa9c2c04cd991

[dblaikie]

llvm/trunk/lib/Bitcode/Reader/MetadataLoader.cpp

1399

Recommitted in ab093bfed7602b74913cc448ad70e27f65aefc28 - seems to have stuck :)

llvm/trunk/include/llvm/IR/DIBuilder.h

public:
     createCompileUnit(unsigned Lang, DIFile *File, StringRef Producer,
                       bool isOptimized, StringRef Flags, unsigned RV,
                       StringRef SplitName = StringRef(),
                       DICompileUnit::DebugEmissionKind Kind =
                           DICompileUnit::DebugEmissionKind::FullDebug,
                       uint64_t DWOId = 0, bool SplitDebugInlining = true,
                       bool DebugInfoForProfiling = false,
                       DICompileUnit::DebugNameTableKind NameTableKind =
-                          DICompileUnit::DebugNameTableKind::Default);
+                          DICompileUnit::DebugNameTableKind::Default,
+                      bool RangesBaseAddress = false);
 
     /// Create a file descriptor to hold debugging information for a file.
     /// \param Filename  File name.
     /// \param Directory Directory.
     /// \param Checksum  Optional checksum kind (e.g. CSK_MD5, CSK_SHA1, etc.)
     ///                  and value.
     /// \param Source    Optional source text.
     DIFile *

llvm/trunk/include/llvm/IR/DebugInfoMetadata.h

private:
   unsigned SourceLanguage;
   bool IsOptimized;
   unsigned RuntimeVersion;
   unsigned EmissionKind;
   uint64_t DWOId;
   bool SplitDebugInlining;
   bool DebugInfoForProfiling;
   unsigned NameTableKind;
+  bool RangesBaseAddress;
 
   DICompileUnit(LLVMContext &C, StorageType Storage, unsigned SourceLanguage,
                 bool IsOptimized, unsigned RuntimeVersion,
                 unsigned EmissionKind, uint64_t DWOId, bool SplitDebugInlining,
                 bool DebugInfoForProfiling, unsigned NameTableKind,
-                ArrayRef<Metadata *> Ops)
+                bool RangesBaseAddress, ArrayRef<Metadata *> Ops)
       : DIScope(C, DICompileUnitKind, Storage, dwarf::DW_TAG_compile_unit, Ops),
         SourceLanguage(SourceLanguage), IsOptimized(IsOptimized),
         RuntimeVersion(RuntimeVersion), EmissionKind(EmissionKind),
         DWOId(DWOId), SplitDebugInlining(SplitDebugInlining),
         DebugInfoForProfiling(DebugInfoForProfiling),
-        NameTableKind(NameTableKind) {
+        NameTableKind(NameTableKind), RangesBaseAddress(RangesBaseAddress) {
     assert(Storage != Uniqued);
   }
   ~DICompileUnit() = default;
 
   static DICompileUnit *
   getImpl(LLVMContext &Context, unsigned SourceLanguage, DIFile *File,
           StringRef Producer, bool IsOptimized, StringRef Flags,
           unsigned RuntimeVersion, StringRef SplitDebugFilename,
           unsigned EmissionKind, DICompositeTypeArray EnumTypes,
           DIScopeArray RetainedTypes,
           DIGlobalVariableExpressionArray GlobalVariables,
           DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
           uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
-          unsigned NameTableKind, StorageType Storage,
+          unsigned NameTableKind, bool RangesBaseAddress, StorageType Storage,
           bool ShouldCreate = true) {
-    return getImpl(
-        Context, SourceLanguage, File, getCanonicalMDString(Context, Producer),
-        IsOptimized, getCanonicalMDString(Context, Flags), RuntimeVersion,
-        getCanonicalMDString(Context, SplitDebugFilename), EmissionKind,
-        EnumTypes.get(), RetainedTypes.get(), GlobalVariables.get(),
-        ImportedEntities.get(), Macros.get(), DWOId, SplitDebugInlining,
-        DebugInfoForProfiling, NameTableKind, Storage, ShouldCreate);
+    return getImpl(Context, SourceLanguage, File,
+                   getCanonicalMDString(Context, Producer), IsOptimized,
+                   getCanonicalMDString(Context, Flags), RuntimeVersion,
+                   getCanonicalMDString(Context, SplitDebugFilename),
+                   EmissionKind, EnumTypes.get(), RetainedTypes.get(),
+                   GlobalVariables.get(), ImportedEntities.get(), Macros.get(),
+                   DWOId, SplitDebugInlining, DebugInfoForProfiling,
+                   NameTableKind, RangesBaseAddress, Storage, ShouldCreate);
   }
   static DICompileUnit *
   getImpl(LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
           MDString *Producer, bool IsOptimized, MDString *Flags,
           unsigned RuntimeVersion, MDString *SplitDebugFilename,
           unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
           Metadata *GlobalVariables, Metadata *ImportedEntities,
           Metadata *Macros, uint64_t DWOId, bool SplitDebugInlining,
           bool DebugInfoForProfiling, unsigned NameTableKind,
-          StorageType Storage, bool ShouldCreate = true);
+          bool RangesBaseAddress, StorageType Storage, bool ShouldCreate = true);
 
   TempDICompileUnit cloneImpl() const {
-    return getTemporary(getContext(), getSourceLanguage(), getFile(),
-                        getProducer(), isOptimized(), getFlags(),
-                        getRuntimeVersion(), getSplitDebugFilename(),
-                        getEmissionKind(), getEnumTypes(), getRetainedTypes(),
-                        getGlobalVariables(), getImportedEntities(),
-                        getMacros(), DWOId, getSplitDebugInlining(),
-                        getDebugInfoForProfiling(), getNameTableKind());
+    return getTemporary(
+        getContext(), getSourceLanguage(), getFile(), getProducer(),
+        isOptimized(), getFlags(), getRuntimeVersion(), getSplitDebugFilename(),
+        getGlobalVariables(), getImportedEntities(), getMacros(), DWOId,
+        getSplitDebugInlining(), getDebugInfoForProfiling(), getNameTableKind(),
+        getRangesBaseAddress());
   }
 
 public:
   static void get() = delete;
   static void getIfExists() = delete;
 
   DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
       DICompileUnit,
       (unsigned SourceLanguage, DIFile *File, StringRef Producer,
        bool IsOptimized, StringRef Flags, unsigned RuntimeVersion,
        StringRef SplitDebugFilename, DebugEmissionKind EmissionKind,
        DICompositeTypeArray EnumTypes, DIScopeArray RetainedTypes,
        DIGlobalVariableExpressionArray GlobalVariables,
        DIImportedEntityArray ImportedEntities, DIMacroNodeArray Macros,
        uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
-       DebugNameTableKind NameTableKind),
+       DebugNameTableKind NameTableKind, bool RangesBaseAddress),
       (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
        SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
        GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
-       DebugInfoForProfiling, (unsigned)NameTableKind))
+       DebugInfoForProfiling, (unsigned)NameTableKind, RangesBaseAddress))
   DEFINE_MDNODE_GET_DISTINCT_TEMPORARY(
       DICompileUnit,
       (unsigned SourceLanguage, Metadata *File, MDString *Producer,
        bool IsOptimized, MDString *Flags, unsigned RuntimeVersion,
        MDString *SplitDebugFilename, unsigned EmissionKind, Metadata *EnumTypes,
        Metadata *RetainedTypes, Metadata *GlobalVariables,
        Metadata *ImportedEntities, Metadata *Macros, uint64_t DWOId,
        bool SplitDebugInlining, bool DebugInfoForProfiling,
-       unsigned NameTableKind),
+       unsigned NameTableKind, bool RangesBaseAddress),
       (SourceLanguage, File, Producer, IsOptimized, Flags, RuntimeVersion,
        SplitDebugFilename, EmissionKind, EnumTypes, RetainedTypes,
        GlobalVariables, ImportedEntities, Macros, DWOId, SplitDebugInlining,
-       DebugInfoForProfiling, NameTableKind))
+       DebugInfoForProfiling, NameTableKind, RangesBaseAddress))
 
   TempDICompileUnit clone() const { return cloneImpl(); }
 
   unsigned getSourceLanguage() const { return SourceLanguage; }
   bool isOptimized() const { return IsOptimized; }
   unsigned getRuntimeVersion() const { return RuntimeVersion; }
   DebugEmissionKind getEmissionKind() const {
     return (DebugEmissionKind)EmissionKind;
   }
   bool isDebugDirectivesOnly() const {
     return EmissionKind == DebugDirectivesOnly;
   }
   bool getDebugInfoForProfiling() const { return DebugInfoForProfiling; }
   DebugNameTableKind getNameTableKind() const {
     return (DebugNameTableKind)NameTableKind;
   }
-  StringRef getProducer() const { return getStringOperand(1); }
-  StringRef getFlags() const { return getStringOperand(2); }
-  StringRef getSplitDebugFilename() const { return getStringOperand(3); }
+  bool getRangesBaseAddress() const {
+    return RangesBaseAddress; }
+  StringRef getProducer() const {
+    return getStringOperand(1); }
+  StringRef getFlags() const {
+    return getStringOperand(2); }
+  StringRef getSplitDebugFilename() const {
+    return getStringOperand(3); }
   DICompositeTypeArray getEnumTypes() const {
     return cast_or_null<MDTuple>(getRawEnumTypes());
   }
   DIScopeArray getRetainedTypes() const {
     return cast_or_null<MDTuple>(getRawRetainedTypes());
   }
   DIGlobalVariableExpressionArray getGlobalVariables() const {
     return cast_or_null<MDTuple>(getRawGlobalVariables());

llvm/trunk/lib/AsmParser/LLParser.cpp

#define VISIT_MD_FIELDS(OPTIONAL, REQUIRED)                                    \
   OPTIONAL(enums, MDField, );                                                  \
   OPTIONAL(retainedTypes, MDField, );                                          \
   OPTIONAL(globals, MDField, );                                                \
   OPTIONAL(imports, MDField, );                                                \
   OPTIONAL(macros, MDField, );                                                 \
   OPTIONAL(dwoId, MDUnsignedField, );                                          \
   OPTIONAL(splitDebugInlining, MDBoolField, = true);                           \
   OPTIONAL(debugInfoForProfiling, MDBoolField, = false);                       \
-  OPTIONAL(nameTableKind, NameTableKindField, );
+  OPTIONAL(nameTableKind, NameTableKindField, );                               \
+  OPTIONAL(debugBaseAddress, MDBoolField, = false);
   PARSE_MD_FIELDS();
 #undef VISIT_MD_FIELDS
 
   Result = DICompileUnit::getDistinct(
       Context, language.Val, file.Val, producer.Val, isOptimized.Val, flags.Val,
       runtimeVersion.Val, splitDebugFilename.Val, emissionKind.Val, enums.Val,
       retainedTypes.Val, globals.Val, imports.Val, macros.Val, dwoId.Val,
-      splitDebugInlining.Val, debugInfoForProfiling.Val, nameTableKind.Val);
+      splitDebugInlining.Val, debugInfoForProfiling.Val, nameTableKind.Val,
+      debugBaseAddress.Val);
   return false;
 }
 
 /// ParseDISubprogram:
 ///   ::= !DISubprogram(scope: !0, name: "foo", linkageName: "_Zfoo",
 ///                     file: !1, line: 7, type: !2, isLocal: false,
 ///                     isDefinition: true, scopeLine: 8, containingType: !3,
 ///                     virtuality: DW_VIRTUALTIY_pure_virtual,

llvm/trunk/lib/Bitcode/Reader/MetadataLoader.cpp

auto *CU = DICompileUnit::getDistinct(
         Context, Record[1], getMDOrNull(Record[2]), getMDString(Record[3]),
         Record[4], getMDString(Record[5]), Record[6], getMDString(Record[7]),
         Record[8], getMDOrNull(Record[9]), getMDOrNull(Record[10]),
         getMDOrNull(Record[12]), getMDOrNull(Record[13]),
         Record.size() <= 15 ? nullptr : getMDOrNull(Record[15]),
         Record.size() <= 14 ? 0 : Record[14],
         Record.size() <= 16 ? true : Record[16],
         Record.size() <= 17 ? false : Record[17],
-        Record.size() <= 18 ? 0 : Record[18]);
+        Record.size() <= 18 ? 0 : Record[18],
+        Record.size() <= 19 ? 0 : Record[19]);
 
     MetadataList.assignValue(CU, NextMetadataNo);
     NextMetadataNo++;
 
     // Move the Upgrade the list of subprograms.
     if (Metadata *SPs = getMDOrNullWithoutPlaceholders(Record[11]))
       CUSubprograms.push_back({CU, SPs});
     break;

llvm/trunk/lib/CodeGen/AsmPrinter/DwarfDebug.cpp

for (const auto &P : SectionRanges) {
     // Don't bother with a base address entry if there's only one range in
     // this section in this range list - for example ranges for a CU will
     // usually consist of single regions from each of many sections
     // (-ffunction-sections, or just C++ inline functions) except under LTO
     // or optnone where there may be holes in a single CU's section
     // contributions.
     auto *Base = CUBase;
     if (!Base && (P.second.size() > 1 || DwarfVersion < 5) &&
-        (UseDwarfRangesBaseAddressSpecifier || DwarfVersion >= 5)) {
+        (CU.getCUNode()->getRangesBaseAddress() || DwarfVersion >= 5)) {
       BaseIsSet = true;
       // FIXME/use care: This may not be a useful base address if it's not
       // the lowest address/range in this object.
       Base = P.second.front()->getStart();
       if (DwarfVersion >= 5) {
         Base = DD.getSectionLabel(&Base->getSection());
         Asm->OutStreamer->AddComment("DW_RLE_base_addressx");
         Asm->OutStreamer->EmitIntValue(dwarf::DW_RLE_base_addressx, 1);

llvm/trunk/lib/IR/AsmWriter.cpp

static void writeDICompileUnit(raw_ostream &Out, const DICompileUnit *N,
   Printer.printMetadata("globals", N->getRawGlobalVariables());
   Printer.printMetadata("imports", N->getRawImportedEntities());
   Printer.printMetadata("macros", N->getRawMacros());
   Printer.printInt("dwoId", N->getDWOId());
   Printer.printBool("splitDebugInlining", N->getSplitDebugInlining(), true);
   Printer.printBool("debugInfoForProfiling", N->getDebugInfoForProfiling(),
                     false);
   Printer.printNameTableKind("nameTableKind", N->getNameTableKind());
+  Printer.printBool("rangesBaseAddress", N->getRangesBaseAddress(), false);
   Out << ")";
 }
 
 static void writeDISubprogram(raw_ostream &Out, const DISubprogram *N,
                               TypePrinting *TypePrinter, SlotTracker *Machine,
                               const Module *Context) {
   Out << "!DISubprogram(";
   MDFieldPrinter Printer(Out, TypePrinter, Machine, Context);

llvm/trunk/lib/IR/DIBuilder.cpp

static DIScope *getNonCompileUnitScope(DIScope *N) {
   return cast<DIScope>(N);
 }
 
 DICompileUnit *DIBuilder::createCompileUnit(
     unsigned Lang, DIFile *File, StringRef Producer, bool isOptimized,
     StringRef Flags, unsigned RunTimeVer, StringRef SplitName,
     DICompileUnit::DebugEmissionKind Kind, uint64_t DWOId,
     bool SplitDebugInlining, bool DebugInfoForProfiling,
-    DICompileUnit::DebugNameTableKind NameTableKind) {
+    DICompileUnit::DebugNameTableKind NameTableKind, bool RangesBaseAddress) {
 
   assert(((Lang <= dwarf::DW_LANG_Fortran08 && Lang >= dwarf::DW_LANG_C89) ||
           (Lang <= dwarf::DW_LANG_hi_user && Lang >= dwarf::DW_LANG_lo_user)) &&
          "Invalid Language tag");
 
   assert(!CUNode && "Can only make one compile unit per DIBuilder instance");
   CUNode = DICompileUnit::getDistinct(
       VMContext, Lang, File, Producer, isOptimized, Flags, RunTimeVer,
       SplitName, Kind, nullptr, nullptr, nullptr, nullptr, nullptr, DWOId,
-      SplitDebugInlining, DebugInfoForProfiling, NameTableKind);
+      SplitDebugInlining, DebugInfoForProfiling, NameTableKind,
+      RangesBaseAddress);
 
   // Create a named metadata so that it is easier to find cu in a module.
   NamedMDNode *NMD = M.getOrInsertNamedMetadata("llvm.dbg.cu");
   NMD->addOperand(CUNode);
   trackIfUnresolved(CUNode);
   return CUNode;
 }
 

llvm/trunk/lib/IR/DebugInfo.cpp

DICompileUnit *getReplacementCU(DICompileUnit *CU) {
     MDTuple *GlobalVariables = nullptr;
     MDTuple *ImportedEntities = nullptr;
     return DICompileUnit::getDistinct(
         CU->getContext(), CU->getSourceLanguage(), File, CU->getProducer(),
         CU->isOptimized(), CU->getFlags(), CU->getRuntimeVersion(),
         CU->getSplitDebugFilename(), DICompileUnit::LineTablesOnly, EnumTypes,
         RetainedTypes, GlobalVariables, ImportedEntities, CU->getMacros(),
         CU->getDWOId(), CU->getSplitDebugInlining(),
-        CU->getDebugInfoForProfiling(), CU->getNameTableKind());
+        CU->getDebugInfoForProfiling(), CU->getNameTableKind(),
+        CU->getRangesBaseAddress());
   }
 
   DILocation *getReplacementMDLocation(DILocation *MLD) {
     auto *Scope = map(MLD->getScope());
     auto *InlinedAt = map(MLD->getInlinedAt());
     if (MLD->isDistinct())
       return DILocation::getDistinct(MLD->getContext(), MLD->getLine(),
                                      MLD->getColumn(), Scope, InlinedAt);

llvm/trunk/lib/IR/DebugInfoMetadata.cpp

 
 DICompileUnit *DICompileUnit::getImpl(
     LLVMContext &Context, unsigned SourceLanguage, Metadata *File,
     MDString *Producer, bool IsOptimized, MDString *Flags,
     unsigned RuntimeVersion, MDString *SplitDebugFilename,
     unsigned EmissionKind, Metadata *EnumTypes, Metadata *RetainedTypes,
     Metadata *GlobalVariables, Metadata *ImportedEntities, Metadata *Macros,
     uint64_t DWOId, bool SplitDebugInlining, bool DebugInfoForProfiling,
-    unsigned NameTableKind, StorageType Storage, bool ShouldCreate) {
+    unsigned NameTableKind, bool RangesBaseAddress, StorageType Storage,
+    bool ShouldCreate) {
   assert(Storage != Uniqued && "Cannot unique DICompileUnit");
   assert(isCanonical(Producer) && "Expected canonical MDString");
   assert(isCanonical(Flags) && "Expected canonical MDString");
   assert(isCanonical(SplitDebugFilename) && "Expected canonical MDString");
 
   Metadata *Ops[] = {
       File,      Producer,      Flags,           SplitDebugFilename,
       EnumTypes, RetainedTypes, GlobalVariables, ImportedEntities,
       Macros};
   return storeImpl(new (array_lengthof(Ops)) DICompileUnit(
                        Context, Storage, SourceLanguage, IsOptimized,
                        RuntimeVersion, EmissionKind, DWOId, SplitDebugInlining,
-                       DebugInfoForProfiling, NameTableKind, Ops),
+                       DebugInfoForProfiling, NameTableKind, RangesBaseAddress,
+                       Ops),
                    Storage);
 }
 
 Optional<DICompileUnit::DebugEmissionKind>
 DICompileUnit::getEmissionKind(StringRef Str) {
   return StringSwitch<Optional<DebugEmissionKind>>(Str)
       .Case("NoDebug", NoDebug)
       .Case("FullDebug", FullDebug)

llvm/trunk/test/DebugInfo/X86/range_reloc.ll

-; RUN: llc -filetype=asm -mtriple=x86_64-pc-linux-gnu %s -o - -use-dwarf-ranges-base-address-specifier | FileCheck --check-prefix=COMMON --check-prefix=BASE %s
-; RUN: llc -filetype=asm -mtriple=x86_64-pc-linux-gnu %s -o - | FileCheck --check-prefix=COMMON --check-prefix=NOBASE %s
+; RUN: llc -filetype=asm -mtriple=x86_64-pc-linux-gnu %s -o - | FileCheck %s
 ; RUN: llc -filetype=asm -mtriple=x86_64-pc-linux-gnu %s -o - -dwarf-version 5 | FileCheck --check-prefix=DWARF5 %s
 
 ; Group ranges in a range list that apply to the same section and use a base
 ; address selection entry to reduce the number of relocations to one reloc per
 ; section per range list. DWARF5 debug_rnglist (with *x variants) are more
 ; efficient than this in terms of relocations, but it's still better than one
 ; reloc per entry in a range list.
 
 ; This is an object/executable size tradeoff - shrinking objects, but growing
 ; the linked executable. In one large binary tested, total object size (not just
 ; debug info) shrank by 16%, entirely relocation entries. Linked executable
 ; grew by 4%. This was with compressed debug info in the objects, uncompressed
 ; in the linked executable. Without compression in the objects, the win would be
 ; smaller (the growth of debug_ranges itself would be more significant).
 
-; COMMON: {{^.Ldebug_ranges0}}
-; NOBASE-NEXT:   .quad   .Lfunc_begin0
-; NOBASE-NEXT:   .quad   .Lfunc_end0
-; NOBASE-NEXT:   .quad   .Lfunc_begin1
-; NOBASE-NEXT:   .quad   .Lfunc_end1
-; NOBASE-NEXT:   .quad   .Lfunc_begin3
-; NOBASE-NEXT:   .quad   .Lfunc_end3
-; NOBASE-NEXT:   .quad   .Lfunc_begin4
-; NOBASE-NEXT:   .quad   .Lfunc_end4
-; NOBASE-NEXT:   .quad   .Lfunc_begin5
-; NOBASE-NEXT:   .quad   .Lfunc_end5
-
-; BASE-NEXT:   .quad   -1
-; BASE-NEXT:   .quad   .Lfunc_begin0
-; BASE-NEXT:   .quad   .Lfunc_begin0-.Lfunc_begin0
-; BASE-NEXT:   .quad   .Lfunc_end0-.Lfunc_begin0
-; BASE-NEXT:   .quad   -1
-; BASE-NEXT:   .quad   .Lfunc_begin1
-; BASE-NEXT:   .quad   .Lfunc_begin1-.Lfunc_begin1
-; BASE-NEXT:   .quad   .Lfunc_end1-.Lfunc_begin1
-; BASE-NEXT:   .quad   .Lfunc_begin3-.Lfunc_begin1
-; BASE-NEXT:   .quad   .Lfunc_end3-.Lfunc_begin1
-; BASE-NEXT:   .quad   -1
-; BASE-NEXT:   .quad   .Lfunc_begin4
-; BASE-NEXT:   .quad   .Lfunc_begin4-.Lfunc_begin4
-; BASE-NEXT:   .quad   .Lfunc_end4-.Lfunc_begin4
-; BASE-NEXT:   .quad   -1
-; BASE-NEXT:   .quad   .Lfunc_begin5
-; BASE-NEXT:   .quad   .Lfunc_begin5-.Lfunc_begin5
-; BASE-NEXT:   .quad   .Lfunc_end5-.Lfunc_begin5
-; COMMON-NEXT:   .quad   0
-; COMMON-NEXT:   .quad   0
+; This is a merged module containing two CUs, one that uses range base address
+; specifiers and exercises different cases there, and another that does not
+
+; ranges.cpp
+; Single range entry
+; __attribute__((section("a"))) void f1() {}
+; Single address with two ranges due to the whole caused by f3
+; __attribute__((section("b"))) void f2() {}
+; __attribute__((section("b"))) __attribute__((nodebug)) void f3() {}
+; __attribute__((section("b"))) void f4() {}
+; Reset the base address & emit a couple more single range entries
+; __attribute__((section("c"))) void f5() {}
+; __attribute__((section("d"))) void f6() {}
+; ranges_no_base.cpp:
+; Include enough complexity to cause ranges to be emitted, so it can be checked
+; that those ranges don't use base address specifiers
+; __attribute__((section("e"))) void f7() {}
+; __attribute__((section("f"))) void f8() {}
+
+; CHECK: {{^.Ldebug_ranges0}}
+; CHECK-NEXT:   .quad   -1
+; CHECK-NEXT:   .quad   .Lfunc_begin0
+; CHECK-NEXT:   .quad   .Lfunc_begin0-.Lfunc_begin0
+; CHECK-NEXT:   .quad   .Lfunc_end0-.Lfunc_begin0
+; CHECK-NEXT:   .quad   -1
+; CHECK-NEXT:   .quad   .Lfunc_begin1
+; CHECK-NEXT:   .quad   .Lfunc_begin1-.Lfunc_begin1
+; CHECK-NEXT:   .quad   .Lfunc_end1-.Lfunc_begin1
+; CHECK-NEXT:   .quad   .Lfunc_begin3-.Lfunc_begin1
+; CHECK-NEXT:   .quad   .Lfunc_end3-.Lfunc_begin1
+; CHECK-NEXT:   .quad   -1
+; CHECK-NEXT:   .quad   .Lfunc_begin4
+; CHECK-NEXT:   .quad   .Lfunc_begin4-.Lfunc_begin4
+; CHECK-NEXT:   .quad   .Lfunc_end4-.Lfunc_begin4
+; CHECK-NEXT:   .quad   -1
+; CHECK-NEXT:   .quad   .Lfunc_begin5
+; CHECK-NEXT:   .quad   .Lfunc_begin5-.Lfunc_begin5
+; CHECK-NEXT:   .quad   .Lfunc_end5-.Lfunc_begin5
+; CHECK-NEXT:   .quad   0
+; CHECK-NEXT:   .quad   0
+; CHECK-NEXT: {{^.Ldebug_ranges1}}
+; CHECK-NEXT:   .quad   .Lfunc_begin6
+; CHECK-NEXT:   .quad   .Lfunc_end6
+; CHECK-NEXT:   .quad   .Lfunc_begin7
+; CHECK-NEXT:   .quad   .Lfunc_end7
 
 ; DWARF5: {{^.Ldebug_ranges0}}
 ; DWARF5-NEXT:                                      # DW_RLE_startx_length
 ; DWARF5-NEXT: .byte 0                              #   start index
 ; DWARF5-NEXT: .uleb128 .Lfunc_end0-.Lfunc_begin0   #   length
 ; DWARF5-NEXT:                                      # DW_RLE_base_addressx
 ; DWARF5-NEXT: .byte 1                              #   base address index
 ; DWARF5-NEXT:                                      # DW_RLE_offset_pair
 ; DWARF5-NEXT: .uleb128 .Lfunc_begin1-.Lfunc_begin1 #   starting offset
 ; DWARF5-NEXT: .uleb128 .Lfunc_end1-.Lfunc_begin1   #   ending offset
 ; DWARF5-NEXT:                                      # DW_RLE_offset_pair
 ; DWARF5-NEXT: .uleb128 .Lfunc_begin3-.Lfunc_begin1 #   starting offset
 ; DWARF5-NEXT: .uleb128 .Lfunc_end3-.Lfunc_begin1   #   ending offset
 ; DWARF5-NEXT:                                      # DW_RLE_startx_length
 ; DWARF5-NEXT: .byte 3                              #   start index
 ; DWARF5-NEXT: .uleb128 .Lfunc_end4-.Lfunc_begin4   #   length
 ; DWARF5-NEXT:                                      # DW_RLE_startx_length
 ; DWARF5-NEXT: .byte 4                              #   start index
 ; DWARF5-NEXT: .uleb128 .Lfunc_end5-.Lfunc_begin5   #   length
 ; DWARF5-NEXT:                                      # DW_RLE_end_of_list
+; DWARF5-NEXT: {{^.Ldebug_ranges1}}
+; DWARF5-NEXT:                                      # DW_RLE_startx_length
+; DWARF5-NEXT: .byte 5                              #   start index
+; DWARF5-NEXT: .uleb128 .Lfunc_end6-.Lfunc_begin6   #   length
+; DWARF5-NEXT:                                      # DW_RLE_startx_length
+; DWARF5-NEXT: .byte 6                              #   start index
+; DWARF5-NEXT: .uleb128 .Lfunc_end7-.Lfunc_begin7   #   length
+; DWARF5-NEXT:                                      # DW_RLE_end_of_list
 
 ; Function Attrs: noinline nounwind optnone uwtable
-define void @_Z2f1v() #0 section "a" !dbg !7 {
+define dso_local void @_Z2f1v() section "a" !dbg !9 {
 entry:
-  ret void, !dbg !10
+  ret void, !dbg !12
 }
 
 ; Function Attrs: noinline nounwind optnone uwtable
-define void @_Z2f2v() #0 section "b" !dbg !11 {
+define dso_local void @_Z2f2v() section "b" !dbg !13 {
 entry:
-  ret void, !dbg !12
+  ret void, !dbg !14
 }
 
 ; Function Attrs: noinline nounwind optnone uwtable
-define void @_Z2f3v() #0 section "b" {
+define dso_local void @_Z2f3v() section "b" {
 entry:
   ret void
 }
 
 ; Function Attrs: noinline nounwind optnone uwtable
-define void @_Z2f4v() #0 section "b" !dbg !13 {
+define dso_local void @_Z2f4v() section "b" !dbg !15 {
 entry:
-  ret void, !dbg !14
+  ret void, !dbg !16
 }
 
 ; Function Attrs: noinline nounwind optnone uwtable
-define void @_Z2f5v() #0 section "e" !dbg !15 {
+define dso_local void @_Z2f5v() section "c" !dbg !17 {
 entry:
-  ret void, !dbg !16
+  ret void, !dbg !18
 }
 
 ; Function Attrs: noinline nounwind optnone uwtable
-define void @_Z2f6v() #0 section "f" !dbg !17 {
+define dso_local void @_Z2f6v() section "d" !dbg !19 {
 entry:
-  ret void, !dbg !18
+  ret void, !dbg !20
 }
 
-attributes #0 = { noinline nounwind optnone uwtable "correctly-rounded-divide-sqrt-fp-math"="false" "disable-tail-calls"="false" "less-precise-fpmad"="false" "no-frame-pointer-elim"="true" "no-frame-pointer-elim-non-leaf" "no-infs-fp-math"="false" "no-jump-tables"="false" "no-nans-fp-math"="false" "no-signed-zeros-fp-math"="false" "no-trapping-math"="false" "stack-protector-buffer-size"="8" "target-cpu"="x86-64" "target-features"="+fxsr,+mmx,+sse,+sse2,+x87" "unsafe-fp-math"="false" "use-soft-float"="false" }
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local void @_Z2f7v() section "e" !dbg !21 {
+entry:
+  ret void, !dbg !22
+}
+
+; Function Attrs: noinline nounwind optnone uwtable
+define dso_local void @_Z2f8v() section "f" !dbg !23 {
+entry:
+  ret void, !dbg !24
+}
 
-!llvm.dbg.cu = !{!0}
-!llvm.module.flags = !{!3, !4, !5}
-!llvm.ident = !{!6}
+!llvm.dbg.cu = !{!0, !3}
+!llvm.ident = !{!5, !5}
+!llvm.module.flags = !{!6, !7, !8}
 
-!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 6.0.0 (trunk 309523) (llvm/trunk 309526)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2)
-!1 = !DIFile(filename: "funcs.cpp", directory: "/usr/local/google/home/blaikie/dev/scratch")
+!0 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !1, producer: "clang version 8.0.0 (trunk 346343) (llvm/trunk 346350)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None, debugBaseAddress: true)
+!1 = !DIFile(filename: "ranges.cpp", directory: "/usr/local/google/home/blaikie/dev/scratch")
 !2 = !{}
-!3 = !{i32 2, !"Dwarf Version", i32 4}
-!4 = !{i32 2, !"Debug Info Version", i32 3}
-!5 = !{i32 1, !"wchar_size", i32 4}
-!6 = !{!"clang version 6.0.0 (trunk 309523) (llvm/trunk 309526)"}
-!7 = distinct !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !8, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
-!8 = !DISubroutineType(types: !9)
-!9 = !{null}
-!10 = !DILocation(line: 1, column: 42, scope: !7)
-!11 = distinct !DISubprogram(name: "f2", linkageName: "_Z2f2v", scope: !1, file: !1, line: 2, type: !8, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
-!12 = !DILocation(line: 2, column: 42, scope: !11)
-!13 = distinct !DISubprogram(name: "f4", linkageName: "_Z2f4v", scope: !1, file: !1, line: 4, type: !8, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
-!14 = !DILocation(line: 4, column: 42, scope: !13)
-!15 = distinct !DISubprogram(name: "f5", linkageName: "_Z2f5v", scope: !1, file: !1, line: 5, type: !8, isLocal: false, isDefinition: true, scopeLine: 5, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
-!16 = !DILocation(line: 5, column: 42, scope: !15)
-!17 = distinct !DISubprogram(name: "f6", linkageName: "_Z2f6v", scope: !1, file: !1, line: 6, type: !8, isLocal: false, isDefinition: true, scopeLine: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
-!18 = !DILocation(line: 6, column: 42, scope: !17)
+!3 = distinct !DICompileUnit(language: DW_LANG_C_plus_plus, file: !4, producer: "clang version 8.0.0 (trunk 346343) (llvm/trunk 346350)", isOptimized: false, runtimeVersion: 0, emissionKind: FullDebug, enums: !2, nameTableKind: None)
+!4 = !DIFile(filename: "ranges_no_base.cpp", directory: "/usr/local/google/home/blaikie/dev/scratch")
+!5 = !{!"clang version 8.0.0 (trunk 346343) (llvm/trunk 346350)"}
+!6 = !{i32 2, !"Dwarf Version", i32 4}
+!7 = !{i32 2, !"Debug Info Version", i32 3}
+!8 = !{i32 1, !"wchar_size", i32 4}
+!9 = distinct !DISubprogram(name: "f1", linkageName: "_Z2f1v", scope: !1, file: !1, line: 1, type: !10, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
+!10 = !DISubroutineType(types: !11)
+!11 = !{null}
+!12 = !DILocation(line: 1, column: 42, scope: !9)
+!13 = distinct !DISubprogram(name: "f2", linkageName: "_Z2f2v", scope: !1, file: !1, line: 2, type: !10, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
+!14 = !DILocation(line: 2, column: 42, scope: !13)
+!15 = distinct !DISubprogram(name: "f4", linkageName: "_Z2f4v", scope: !1, file: !1, line: 4, type: !10, isLocal: false, isDefinition: true, scopeLine: 4, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
+!16 = !DILocation(line: 4, column: 42, scope: !15)
+!17 = distinct !DISubprogram(name: "f5", linkageName: "_Z2f5v", scope: !1, file: !1, line: 5, type: !10, isLocal: false, isDefinition: true, scopeLine: 5, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
+!18 = !DILocation(line: 5, column: 42, scope: !17)
+!19 = distinct !DISubprogram(name: "f6", linkageName: "_Z2f6v", scope: !1, file: !1, line: 6, type: !10, isLocal: false, isDefinition: true, scopeLine: 6, flags: DIFlagPrototyped, isOptimized: false, unit: !0, retainedNodes: !2)
+!20 = !DILocation(line: 6, column: 42, scope: !19)
+!21 = distinct !DISubprogram(name: "f7", linkageName: "_Z2f7v", scope: !4, file: !4, line: 1, type: !10, isLocal: false, isDefinition: true, scopeLine: 1, flags: DIFlagPrototyped, isOptimized: false, unit: !3, retainedNodes: !2)
+!22 = !DILocation(line: 1, column: 42, scope: !21)
+!23 = distinct !DISubprogram(name: "f8", linkageName: "_Z2f8v", scope: !4, file: !4, line: 2, type: !10, isLocal: false, isDefinition: true, scopeLine: 2, flags: DIFlagPrototyped, isOptimized: false, unit: !3, retainedNodes: !2)
+!24 = !DILocation(line: 2, column: 42, scope: !23)

llvm/trunk/unittests/IR/MetadataTest.cpp

protected:
   DIFile *getFile() {
     return DIFile::getDistinct(Context, "file.c", "/path/to/dir");
   }
   DICompileUnit *getUnit() {
     return DICompileUnit::getDistinct(
         Context, 1, getFile(), "clang", false, "-g", 2, "",
         DICompileUnit::FullDebug, getTuple(), getTuple(), getTuple(),
         getTuple(), getTuple(), 0, true, false,
-        DICompileUnit::DebugNameTableKind::Default);
+        DICompileUnit::DebugNameTableKind::Default, false);
   }
   DIType *getBasicType(StringRef Name) {
     return DIBasicType::get(Context, dwarf::DW_TAG_unspecified_type, Name);
   }
   DIType *getDerivedType() {
     return DIDerivedType::getDistinct(
         Context, dwarf::DW_TAG_pointer_type, "", nullptr, 0, nullptr,
         getBasicType("basictype"), 1, 2, 0, None, DINode::FlagZero);
TEST_F(DICompileUnitTest, get) {
   MDTuple *GlobalVariables = getTuple();
   MDTuple *ImportedEntities = getTuple();
   uint64_t DWOId = 0x10000000c0ffee;
   MDTuple *Macros = getTuple();
   auto *N = DICompileUnit::getDistinct(
       Context, SourceLanguage, File, Producer, IsOptimized, Flags,
       RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
       RetainedTypes, GlobalVariables, ImportedEntities, Macros, DWOId, true,
-      false, DICompileUnit::DebugNameTableKind::Default);
+      false, DICompileUnit::DebugNameTableKind::Default, false);
 
   EXPECT_EQ(dwarf::DW_TAG_compile_unit, N->getTag());
   EXPECT_EQ(SourceLanguage, N->getSourceLanguage());
   EXPECT_EQ(File, N->getFile());
   EXPECT_EQ(Producer, N->getProducer());
   EXPECT_EQ(IsOptimized, N->isOptimized());
   EXPECT_EQ(Flags, N->getFlags());
   EXPECT_EQ(RuntimeVersion, N->getRuntimeVersion());
TEST_F(DICompileUnitTest, replaceArrays) {
   MDTuple *EnumTypes = MDTuple::getDistinct(Context, None);
   MDTuple *RetainedTypes = MDTuple::getDistinct(Context, None);
   MDTuple *ImportedEntities = MDTuple::getDistinct(Context, None);
   uint64_t DWOId = 0xc0ffee;
   auto *N = DICompileUnit::getDistinct(
       Context, SourceLanguage, File, Producer, IsOptimized, Flags,
       RuntimeVersion, SplitDebugFilename, EmissionKind, EnumTypes,
       RetainedTypes, nullptr, ImportedEntities, nullptr, DWOId, true, false,
-      DICompileUnit::DebugNameTableKind::Default);
+      DICompileUnit::DebugNameTableKind::Default, false);
 
   auto *GlobalVariables = MDTuple::getDistinct(Context, None);
   EXPECT_EQ(nullptr, N->getGlobalVariables().get());
   N->replaceGlobalVariables(GlobalVariables);
   EXPECT_EQ(GlobalVariables, N->getGlobalVariables().get());
   N->replaceGlobalVariables(nullptr);
   EXPECT_EQ(nullptr, N->getGlobalVariables().get());