Revert [MC][ELF] Emit separate unique sections for different flags

[nikic]

Summary

D100944 broke the ability to specify custom section flags in LLVM IR by including an empty section with the desired flags in module asm. This functionality is used by rustc to embed LTO bitcode with the SHF_EXCLUDE flag, and currently blocks our evaluation of the LLVM 13 release. As the post-commit discussion on D100944 indicates, other people were using this functionality as well: https://reviews.llvm.org/D100944#2840948

This reverts D100944 to restore the ability to set section flags. The change from D100944 can be reapplied once LLVM provides an alternative way to specify section flags -- it would certainly be better if it were possible to do this using a dedicated IR construct. But I don't think it's possible to add such a construct for the LLVM 13 release anymore, so this reverts to the status quo.

Fixes https://bugs.llvm.org/show_bug.cgi?id=51207.

[MaskRay]

This functionality is used by rustc to embed LTO bitcode with the SHF_EXCLUDE flag, and currently blocks our evaluation of the LLVM 13 release.

But Rust usage is technically incorrect. I think Rust can carry its own patch to for the LLVM 13 release.

As the post-commit discussion on D100944 indicates, other people were using this functionality as well: https://reviews.llvm.org/D100944#2840948

I think @bd1976llvm have found a way forward.

This cannot be used as an argument favoring the revert: the code abuses a property which cannot be guaranteed by the assembler.

[nikic]

In D107216#2918203, @MaskRay wrote:

This functionality is used by rustc to embed LTO bitcode with the SHF_EXCLUDE flag, and currently blocks our evaluation of the LLVM 13 release.

But Rust usage is technically incorrect. I think Rust can carry its own patch to for the LLVM 13 release.

I mean, we're happy to carry the patch, but that does mean that all distros are going to carry it as well (as they ship rust linked against system LLVM). I prefer upstreaming the fix over this being a "de facto" LLVM 13 patch that everyone is required to apply independently. I'll leave it to @tstellar to decide.

To be clear, I don't particularly care about the change that D100944 did, the only thing I care about is that it resulted in an effective loss of functionality. If it's possible to add a first-class way to set section flags in IR and backport it to LLVM 13, I will be perfectly happy with that.

[MaskRay]

In D107216#2918235, @nikic wrote:

In D107216#2918203, @MaskRay wrote:

This functionality is used by rustc to embed LTO bitcode with the SHF_EXCLUDE flag, and currently blocks our evaluation of the LLVM 13 release.

But Rust usage is technically incorrect. I think Rust can carry its own patch to for the LLVM 13 release.

I mean, we're happy to carry the patch, but that does mean that all distros are going to carry it as well (as they ship rust linked against system LLVM). I prefer upstreaming the fix over this being a "de facto" LLVM 13 patch that everyone is required to apply independently. I'll leave it to @tstellar to decide.

To be clear, I don't particularly care about the change that D100944 did, the only thing I care about is that it resulted in an effective loss of functionality. If it's possible to add a first-class way to set section flags in IR and backport it to LLVM 13, I will be perfectly happy with that.

Rust's current is flawed in another way: it assumes that module asm is emitted before rustc.embedded.module
The Rust workaround is weighted against breaking correctness and @tmatheson 's workflow.

(The Rust comment says "* Mach-O - this is for macOS. Inspecting the source code for the native ... ". I am not sure how important the feature is to ELF.)

Rust can try other approaches, e.g. replacing mixed module asm & rustc.embedded.module with pure module asm (.ascii "abc" or .incbin "file").
That will not break correctness and @tmatheson 's workflow.

[bd1976llvm]

In D107216#2918203, @MaskRay wrote:

I think @bd1976llvm have found a way forward.

We haven't yet solved this satisfactorily and we are still investigating; however, we don't want LLVM's behaviour compromised to support our use-case.
We would support a proper feature to assign symbols to sections with specified flags (especially as GNU appear to offer this as a feature/*horrible hack* : see comments on https://reviews.llvm.org/D100944).

[cuviper]

Rust's LLVM fork has the revert, but this is still going to be a problem for Rust with system LLVM 13. Do we have a way forward for this release? A revert seems to be a safer path than trying to develop something new in short time.

Even if the former behavior wasn't guaranteed, it still worked well enough in practice, so right now we have a functional regression.

[MaskRay]

In D107216#2990511, @cuviper wrote:

Rust's LLVM fork has the revert, but this is still going to be a problem for Rust with system LLVM 13. Do we have a way forward for this release? A revert seems to be a safer path than trying to develop something new in short time.

Even if the former behavior wasn't guaranteed, it still worked well enough in practice, so right now we have a functional regression.

Rust abused the previous LLVM behavior when an inline asm .section directive can override the section attributes of section ".llvmbc".
LLVM doesn't provide such guarantee.
In addition, the Rust comment mentions that it knows the approach is a hack.

I have made a suggestion that: Rust can try other approaches, e.g. replacing mixed module asm & rustc.embedded.module with pure module asm (.ascii "abc" or .incbin "file").
Have you tried it?

@cuviper Not exploring a proper approach forward, but just trigger-happily reverting a correct change and breaking the original author (and others)' workflow is not IMHO the correct approach.

[tstellar]

What if we reverted the original change in the release/13.x branch only and kept the patch in trunk? This would give rust ~4 months to work on a proper solution which should be enough time.

[MaskRay]

Reverting *only* in release/13.x looks good to me.

[tstellar]

What's the correct way to fix this in the release/13.x branch? Should I apply this patch or revert 165321b3d27de5349520b5fdb7e08cbd238c880f?

[MaskRay]

Applying this patch. git revert -n 165321b3d27de5349520b5fdb7e08cbd238c880f seems to have merge conflicts.

But I'd definitely reword the commit message since the current one is unfair to the functional fix IMO:

Rust has a fragile embed-bitcode implementation (https://github.com/rust-lang/rust/blob/bddb59cf07efcf6e606f16b87f85e3ecd2c1ca69/compiler/rustc_codegen_llvm/src/back/write.rs#L970-L1017) which relied on the previous LLVM MC behavior.
Rust's LLVM fork has carried a revert. This commit made the similar revert to help distributions since they would otherwise probably carry a similar patch (as they ship rust linked against system LLVM).

[nikic]

Abandoning this now that rustc has implemented the necessary workaround (see https://github.com/rust-lang/rust/issues/90326). The revert should no longer be needed from our side.

llvm/include/llvm/MC/MCContext.h

struct ELFEntrySizeKey {
       unsigned EntrySize;
 
       ELFEntrySizeKey(StringRef SectionName, unsigned Flags, unsigned EntrySize)
           : SectionName(SectionName), Flags(Flags), EntrySize(EntrySize) {}
 
       bool operator<(const ELFEntrySizeKey &Other) const {
         if (SectionName != Other.SectionName)
           return SectionName < Other.SectionName;
-        if (Flags != Other.Flags)
-          return Flags < Other.Flags;
+        if ((Flags & ELF::SHF_STRINGS) != (Other.Flags & ELF::SHF_STRINGS))
+          return Other.Flags & ELF::SHF_STRINGS;
         return EntrySize < Other.EntrySize;
       }
     };
 
-    // Symbols must be assigned to a section with a compatible entry size and
-    // flags. This map is used to assign unique IDs to sections to distinguish
-    // between sections with identical names but incompatible entry sizes and/or
-    // flags. This can occur when a symbol is explicitly assigned to a section,
-    // e.g. via __attribute__((section("myname"))).
+    // Symbols must be assigned to a section with a compatible entry
+    // size. This map is used to assign unique IDs to sections to
+    // distinguish between sections with identical names but incompatible entry
+    // sizes. This can occur when a symbol is explicitly assigned to a
+    // section, e.g. via __attribute__((section("myname"))).
     std::map<ELFEntrySizeKey, unsigned> ELFEntrySizeMap;
 
     // This set is used to record the generic mergeable section names seen.
     // These are sections that are created as mergeable e.g. .debug_str. We need
     // to avoid assigning non-mergeable symbols to these sections. It is used
     // to prevent non-mergeable symbols being explicitly assigned  to mergeable
     // sections (e.g. via _attribute_((section("myname")))).
     DenseSet<StringRef> ELFSeenGenericMergeableSections;
public:
 
     void recordELFMergeableSectionInfo(StringRef SectionName, unsigned Flags,
                                        unsigned UniqueID, unsigned EntrySize);
 
     bool isELFImplicitMergeableSectionNamePrefix(StringRef Name);
 
     bool isELFGenericMergeableSection(StringRef Name);
 
-    /// Return the unique ID of the section with the given name, flags and entry
-    /// size, if it exists.
     Optional<unsigned> getELFUniqueIDForEntsize(StringRef SectionName,
                                                 unsigned Flags,
                                                 unsigned EntrySize);
 
     MCSectionGOFF *getGOFFSection(StringRef Section, SectionKind Kind);
 
     MCSectionCOFF *getCOFFSection(StringRef Section, unsigned Characteristics,
                                   SectionKind Kind, StringRef COMDATSymName,

llvm/lib/MC/MCContext.cpp

return createELFSectionImpl(".group", ELF::SHT_GROUP, 0,
                               SectionKind::getReadOnly(), 4, Group, IsComdat,
                               MCSection::NonUniqueID, nullptr);
 }
 
 void MCContext::recordELFMergeableSectionInfo(StringRef SectionName,
                                               unsigned Flags, unsigned UniqueID,
                                               unsigned EntrySize) {
   bool IsMergeable = Flags & ELF::SHF_MERGE;
-  if (UniqueID == GenericSectionID)
+  if (IsMergeable && (UniqueID == GenericSectionID))
     ELFSeenGenericMergeableSections.insert(SectionName);
 
   // For mergeable sections or non-mergeable sections with a generic mergeable
   // section name we enter their Unique ID into the ELFEntrySizeMap so that
   // compatible globals can be assigned to the same section.
   if (IsMergeable || isELFGenericMergeableSection(SectionName)) {
     ELFEntrySizeMap.insert(std::make_pair(
         ELFEntrySizeKey{SectionName, Flags, EntrySize}, UniqueID));

llvm/test/CodeGen/Mips/gpopt-explict-section.ll

 ; RUN: llc < %s -march=mips -mcpu=mips32 -mips-ssection-threshold=8 \
 ; RUN:     -relocation-model=static -mattr=+noabicalls -mgpopt \
 ; RUN:   | FileCheck %s
 
 ; Test that object with an explicit section that is not .sdata or .sbss are not
 ; considered in the small data section if they would otherwise qualify to be in
 ; small data section. Also test that explicitly placing something in the small
 ; data section uses %gp_rel addressing mode.
 
-@a = constant [2 x i32] zeroinitializer, section ".rodata", align 4
+@a = global [2 x i32] zeroinitializer, section ".rodata", align 4
 @b = global [4 x i32] zeroinitializer, section ".sdata", align 4
 @c = global [4 x i32] zeroinitializer, section ".sbss", align 4
 
 ; CHECK-LABEL: g
 ; CHECK:       lui $[[R:[0-9]+]], %hi(a)
 ; CHECK:       lw  ${{[0-9]+}}, %lo(a)($[[R]])
 
 define i32 @g() {

llvm/test/CodeGen/X86/elf-unique-sections-by-flags.ll

-; Test that global values with the same specified section produces multiple
-; sections with different sets of flags, depending on the properties (mutable,
-; executable) of the global value.
-
-; RUN: llc < %s | FileCheck %s
-; RUN: llc -function-sections < %s | FileCheck %s --check-prefix=CHECK --check-prefix=FNSECTIONS
-target triple="x86_64-unknown-unknown-elf"
-
-; Normal function goes in .text, or in it's own named section with -function-sections.
-define i32 @fn_text() {
-    entry:
-    ret i32 0
-}
-; CHECK:        .text{{$}}
-; CHECK-NEXT:   .file
-; FNSECTIONS:   .section  .text.fn_text,"ax",@progbits{{$}}
-; CHECK-NEXT:   .globl fn_text
-; CHECK:        fn_text:
-
-; A second function placed in .text, to check the behaviour with -function-sections.
-; It should be emitted to a new section with a new name, not expected to require unique.
-define i32 @fn_text2() {
-    entry:
-    ret i32 0
-}
-; FNSECTIONS:   .section  .text.fn_text2,"ax",@progbits{{$}}
-; CHECK:        .globl fn_text2
-; CHECK:        fn_text2:
-
-; Functions in user defined executable sections
-define i32 @fn_s1() section "s1" {
-    entry:
-    ret i32 0
-}
-; CHECK:        .section s1,"ax",@progbits{{$}}
-; CHECK-NEXT:   .globl fn_s1
-; CHECK:        fn_s1:
-
-define i32 @fn_s2() section "s2" {
-    entry:
-    ret i32 0
-}
-; CHECK:        .section s2,"ax",@progbits{{$}}
-; CHECK-NEXT:   .globl fn_s2
-; CHECK:        fn_s2:
-
-; A second function in s2 should share the same .section
-define i32 @fn2_s2() section "s2" {
-    entry:
-    ret i32 0
-}
-; CHECK-NOT:    .section
-; CHECK:        .globl fn2_s2
-; CHECK:        fn2_s2:
-
-; Values that share a section name with a function are placed in different sections without executable flag
-@rw_s1 = global i32 10, section "s1", align 4
-@ro_s2 = constant i32 10, section "s2", align 4
-; CHECK:        .section s1,"aw",@progbits,unique,[[#UNIQUE_S1_aw:]]
-; CHECK-NEXT:   .globl rw_s1
-; CHECK:        rw_s1:
-; CHECK:        .section s2,"a",@progbits,unique,[[#UNIQUE_S2_a:]]
-; CHECK-NEXT:   .globl ro_s2
-; CHECK:        ro_s2:
-
-; Placing another value in the same section with the same flags uses the same unique ID
-@rw2_s1 = global i32 10, section "s1", align 4
-@ro2_s2 = constant i32 10, section "s2", align 4
-; CHECK:        .section s1,"aw",@progbits,unique,[[#UNIQUE_S1_aw]]
-; CHECK-NEXT:   .globl rw2_s1
-; CHECK:        rw2_s1:
-; CHECK:        .section s2,"a",@progbits,unique,[[#UNIQUE_S2_a]]
-; CHECK-NEXT:   .globl ro2_s2
-; CHECK:        ro2_s2:
-
-; Normal user defined section, first is the generic section, second should be unique
-@ro_s3 = constant i32 10, section "s3", align 4
-@rw_s3 = global i32 10, section "s3", align 4
-; CHECK:        .section s3,"a",@progbits{{$}}
-; CHECK-NEXT:   .globl ro_s3
-; CHECK:        ro_s3:
-; CHECK:        .section s3,"aw",@progbits,unique,[[#U:]]
-; CHECK-NEXT:   .globl rw_s3
-; CHECK:        rw_s3:
-
-; Values declared without explicit sections go into compatible default sections and don't require unique
-@rw_nosec = global i32 10, align 4
-@ro_nosec = constant i32 10, align 4
-; CHECK:        .data{{$}}
-; CHECK-NEXT:   .globl rw_nosec
-; CHECK:        rw_nosec:
-; CHECK:        .section .rodata,"a",@progbits{{$}}
-; CHECK-NEXT:   .globl ro_nosec
-; CHECK:        ro_nosec:
-
-; Explicitly placed in .rodata with writeable set. The writable section should be uniqued, not the default ro section, even if it comes first.
-@rw_rodata = global [2 x i32] zeroinitializer, section ".rodata", align 4
-@ro_rodata = constant [2 x i32] zeroinitializer, section ".rodata", align 4
-; CHECK:        .section .rodata,"aw",@progbits,unique,[[#U+1]]{{$}}
-; CHECK-NEXT:   .globl rw_rodata{{$}}
-; CHECK:        rw_rodata:
-; CHECK:        .section .rodata,"a",@progbits{{$}}
-; CHECK-NEXT:   .globl ro_rodata{{$}}
-; CHECK:        ro_rodata:
-
-; Writable symbols in writable default sections; no need to unique
-@w_sdata = global [4 x i32] zeroinitializer, section ".sdata", align 4
-@w_sbss = global [4 x i32] zeroinitializer, section ".sbss", align 4
-; CHECK:        .section .sdata,"aw",@progbits{{$}}
-; CHECK-NEXT:   .globl w_sdata{{$}}
-; CHECK:        w_sdata:
-; CHECK:        .section .sbss,"aw",@nobits{{$}}
-; CHECK-NEXT:   .globl w_sbss{{$}}
-; CHECK:        w_sbss:
-
-; Multiple .text sections are emitted for read-only and read-write sections using .text name.
-@rw_text = global i32 10, section ".text", align 4
-@ro_text = constant i32 10, section ".text", align 4
-; CHECK:        .section .text,"aw",@progbits,unique,[[#U+2]]
-; CHECK-NEXT:   .globl rw_text
-; CHECK:        rw_text:
-; CHECK:        .section .text,"a",@progbits,unique,[[#U+3]]
-; CHECK-NEXT:   .globl ro_text
-; CHECK:        ro_text:
-
-; A read-only .data section is emitted
-@ro_data = constant i32 10, section ".data", align 4
-; CHECK:        .section .data,"a",@progbits,unique,[[#U+4]]
-; CHECK-NEXT:   .globl ro_data
-; CHECK:        ro_data:
-
-; TLS and non-TLS symbols cannot live in the same section
-@tls_var = thread_local global i32 10, section "s4", align 4
-@non_tls_var = global i32 10, section "s4", align 4
-; CHECK:        .section s4,"awT",@progbits{{$}}
-; CHECK-NEXT:   .globl tls_var
-; CHECK:        tls_var:
-; CHECK:        .section s4,"aw",@progbits,unique,[[#U+5]]
-; CHECK-NEXT:   .globl non_tls_var
-; CHECK:        non_tls_var:

llvm/test/CodeGen/X86/explicit-section-mergeable.ll

 ; RUN: llc < %s -mtriple=x86_64 -unique-section-names=0 -data-sections 2>&1 \
 ; RUN:     | FileCheck %s
 
 ;; Several sections are created via inline assembly. We add checks
 ;; for these lines as we want to use --implicit-check-not to reduce the
 ;; number of checks in this file.
-; CHECK: .section .asm_mergeable1,"aMS",@progbits,2{{$}}
-; CHECK-NEXT: .section .asm_nonmergeable1,"a",@progbits{{$}}
-; CHECK-NEXT: .section .asm_mergeable2,"aMS",@progbits,2{{$}}
-; CHECK-NEXT: .section .asm_nonmergeable2,"a",@progbits{{$}}
+; CHECK: .section .asm_mergeable1,"aMS",@progbits,2
+; CHECK-NEXT: .section .asm_nonmergeable1,"a",@progbits
+; CHECK-NEXT: .section .asm_mergeable2,"aMS",@progbits,2
+; CHECK-NEXT: .section .asm_nonmergeable2,"a",@progbits
 
 ;; Test implicit section assignment for symbols
 ; CHECK: .section .data,"aw",@progbits,unique,1
 ; CHECK: uniquified:
 
 ;; Create a uniquified symbol (as -unique-section-names=0) to test the uniqueID
 ;; interaction with mergeable symbols.
 @uniquified = global i32 1
 
 ;; Test implicit section assignment for symbols to ensure that the symbols
 ;; have the expected properties.
 ; CHECK: .section .rodata,"a",@progbits,unique,2
 ; CHECK: implicit_nonmergeable:
-; CHECK: .section .rodata.cst4,"aM",@progbits,4{{$}}
+; CHECK: .section .rodata.cst4,"aM",@progbits,4
 ; CHECK: implicit_rodata_cst4:
-; CHECK: .section .rodata.cst8,"aM",@progbits,8{{$}}
+; CHECK: .section .rodata.cst8,"aM",@progbits,8
 ; CHECK: implicit_rodata_cst8:
-; CHECK: .section .rodata.str4.4,"aMS",@progbits,4{{$}}
+; CHECK: .section .rodata.str4.4,"aMS",@progbits,4
 ; CHECK: implicit_rodata_str4_4:
 
 @implicit_nonmergeable  =              constant [2 x i16] [i16 1, i16 1]
 @implicit_rodata_cst4   = unnamed_addr constant [2 x i16] [i16 1, i16 1]
 @implicit_rodata_cst8   = unnamed_addr constant [2 x i32] [i32 1, i32 1]
 @implicit_rodata_str4_4 = unnamed_addr constant [2 x i32] [i32 1, i32 0]
 
 ;; Basic checks that mergeable globals are placed into multiple distinct

 ; CHECK: explicit_basic_5:
 ; CHECK: explicit_basic_6:
 
 ;; Assign a symbol with an incompatible entsize (string vs non-string) to a section with the same name.
 @explicit_basic_5 = unnamed_addr constant [2 x i32] [i32 1, i32 0], section ".explicit_basic"
 ;; Assign a compatible mergeable global to the previous section.
 @explicit_basic_6 = unnamed_addr constant [2 x i32] [i32 1, i32 0], section ".explicit_basic"
 
-; CHECK: .section .explicit_basic,"a",@progbits{{$}}
+; CHECK: .section .explicit_basic,"a",@progbits
 ; CHECK: explicit_basic_7:
 
 ;; Assign a symbol with an incompatible entsize (non-mergeable) to a mergeable section created explicitly.
 @explicit_basic_7 = constant [2 x i16] [i16 1, i16 1], section ".explicit_basic"
 
-; CHECK: .section .explicit_initially_nonmergeable,"a",@progbits{{$}}
+; CHECK: .section .explicit_initially_nonmergeable,"a",@progbits
 ; CHECK: explicit_basic_8:
 ; CHECK: .section .explicit_initially_nonmergeable,"aM",@progbits,4,unique,6
 ; CHECK: explicit_basic_9:
 
 ;; Assign a mergeble symbol to a section that initially had a non-mergeable symbol explicitly assigned to it.
 @explicit_basic_8 = constant [2 x i16] [i16 1, i16 1], section ".explicit_initially_nonmergeable"
 @explicit_basic_9 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_initially_nonmergeable"
 
-; CHECK: .section .explicit_initially_nonmergeable,"a",@progbits{{$}}
+; CHECK: .section .explicit_initially_nonmergeable,"a",@progbits
 ; CHECK: explicit_basic_10:
 ; CHECK: .section .explicit_initially_nonmergeable,"aM",@progbits,4,unique,6
 ; CHECK: explicit_basic_11:
 
 ;; Assign compatible globals to the previously created sections.
 @explicit_basic_10 = constant [2 x i16] [i16 1, i16 1], section ".explicit_initially_nonmergeable"
 @explicit_basic_11 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_initially_nonmergeable"
 
 ;; Check that mergeable symbols can be explicitly assigned to "default" sections.
 
 ; CHECK: .section .rodata.cst16,"a",@progbits,unique,7
 ; CHECK: explicit_default_1:
 
 ;; Assign an incompatible (non-mergeable) symbol to a "default" mergeable section.
 @explicit_default_1 = constant [2 x i64] [i64 1, i64 1], section ".rodata.cst16"
 
-; CHECK: .section .rodata.cst16,"aM",@progbits,16{{$}}
+; CHECK: .section .rodata.cst16,"aM",@progbits,16
 ; CHECK: explicit_default_2:
 
 ;; Assign a compatible global to a "default" mergeable section.
 @explicit_default_2 = unnamed_addr constant [2 x i64] [i64 1, i64 1], section ".rodata.cst16"
 
-; CHECK: .section .debug_str,"aMS",@progbits,1,unique,[[#U:8]]
+; CHECK: .section .debug_str,"MS",@progbits,1
 ; CHECK: explicit_default_3:
 
-;; Non-allocatable "default" sections can be re-emitted with allocatable flag and uniqued
+;; Non-allocatable "default" sections can have allocatable mergeable symbols with compatible entry sizes assigned to them.
 @explicit_default_3 = unnamed_addr constant [2 x i8] [i8 1, i8 0], section ".debug_str"
 
-; CHECK: .section .debug_str,"a",@progbits,unique,[[#U+1]]
+; CHECK: .section .debug_str,"a",@progbits,unique,8
 ; CHECK: explicit_default_4:
 
 ;; Non-allocatable "default" sections cannot have allocatable mergeable symbols with incompatible (non-mergeable) entry sizes assigned to them.
 @explicit_default_4 = constant [2 x i16] [i16 1, i16 1], section ".debug_str"
 
 ;; Test implicit section assignment for globals with associated globals.
-; CHECK: .section .rodata.cst4,"aMo",@progbits,4,implicit_rodata_cst4,unique,[[#U+2]]
+; CHECK: .section .rodata.cst4,"aMo",@progbits,4,implicit_rodata_cst4,unique,9
 ; CHECK: implicit_rodata_cst4_assoc:
-; CHECK: .section .rodata.cst8,"aMo",@progbits,8,implicit_rodata_cst4,unique,[[#U+3]]
+; CHECK: .section .rodata.cst8,"aMo",@progbits,8,implicit_rodata_cst4,unique,10
 ; CHECK: implicit_rodata_cst8_assoc:
 
 @implicit_rodata_cst4_assoc = unnamed_addr constant [2 x i16] [i16 1, i16 1], !associated !4
 @implicit_rodata_cst8_assoc = unnamed_addr constant [2 x i32] [i32 1, i32 1], !associated !4
 
 ;; Check that globals with associated globals that are explicitly assigned
 ;; to a section have been placed into distinct sections with the same name, but
 ;; different entry sizes.
-; CHECK: .section .explicit,"aMo",@progbits,4,implicit_rodata_cst4,unique,[[#U+4]]
+; CHECK: .section .explicit,"aMo",@progbits,4,implicit_rodata_cst4,unique,11
 ; CHECK: explicit_assoc_1:
-; CHECK: .section .explicit,"aMo",@progbits,4,implicit_rodata_cst4,unique,[[#U+5]]
+; CHECK: .section .explicit,"aMo",@progbits,4,implicit_rodata_cst4,unique,12
 ; CHECK: explicit_assoc_2:
-; CHECK: .section .explicit,"aMo",@progbits,8,implicit_rodata_cst4,unique,[[#U+6]]
+; CHECK: .section .explicit,"aMo",@progbits,8,implicit_rodata_cst4,unique,13
 ; CHECK: explicit_assoc_3:
 
 @explicit_assoc_1 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit", !associated !4
 @explicit_assoc_2 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit", !associated !4
 @explicit_assoc_3 = unnamed_addr constant [2 x i32] [i32 1, i32 1], section ".explicit", !associated !4
 
 !4 = !{[2 x i16]* @implicit_rodata_cst4}
 
 ;; Test implicit section assignment for globals in distinct comdat groups.
-; CHECK: .section .rodata.cst4,"aGM",@progbits,4,f,comdat,unique,[[#U+7]]
+; CHECK: .section .rodata.cst4,"aGM",@progbits,4,f,comdat,unique,14
 ; CHECK: implicit_rodata_cst4_comdat:
-; CHECK: .section .rodata.cst8,"aGM",@progbits,8,g,comdat,unique,[[#U+8]]
+; CHECK: .section .rodata.cst8,"aGM",@progbits,8,g,comdat,unique,15
 ; CHECK: implicit_rodata_cst8_comdat:
 
 ;; Check that globals in distinct comdat groups that are explicitly assigned
 ;; to a section have been placed into distinct sections with the same name, but
 ;; different entry sizes. Due to the way that MC currently works the unique ID
 ;; does not have any effect here, although it appears in the assembly. The unique ID's
 ;; appear incorrect as comdats are not taken into account when looking up the unique ID
 ;; for a mergeable section. However, as they have no effect it doesn't matter that they
 ;; are incorrect.
-; CHECK: .section .explicit_comdat_distinct,"aM",@progbits,4,unique,[[#U+9]]
+; CHECK: .section .explicit_comdat_distinct,"aM",@progbits,4,unique,16
 ; CHECK: explicit_comdat_distinct_supply_uid:
-; CHECK: .section .explicit_comdat_distinct,"aGM",@progbits,4,f,comdat,unique,[[#U+10]]
+; CHECK: .section .explicit_comdat_distinct,"aGM",@progbits,4,f,comdat,unique,16
 ; CHECK: explicit_comdat_distinct1:
-; CHECK: .section .explicit_comdat_distinct,"aGM",@progbits,4,g,comdat,unique,[[#U+10]]
+; CHECK: .section .explicit_comdat_distinct,"aGM",@progbits,4,g,comdat,unique,16
 ; CHECK: explicit_comdat_distinct2:
-; CHECK: .section .explicit_comdat_distinct,"aGM",@progbits,8,h,comdat,unique,[[#U+11]]
+; CHECK: .section .explicit_comdat_distinct,"aGM",@progbits,8,h,comdat,unique,17
 ; CHECK: explicit_comdat_distinct3:
 
 $f = comdat any
 $g = comdat any
 $h = comdat any
 
 @implicit_rodata_cst4_comdat = unnamed_addr constant [2 x i16] [i16 1, i16 1], comdat($f)
 @implicit_rodata_cst8_comdat = unnamed_addr constant [2 x i32] [i32 1, i32 1], comdat($g)
 
 @explicit_comdat_distinct_supply_uid = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_distinct"
 @explicit_comdat_distinct1 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_distinct", comdat($f)
 @explicit_comdat_distinct2 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_distinct", comdat($g)
 @explicit_comdat_distinct3 = unnamed_addr constant [2 x i32] [i32 1, i32 1], section ".explicit_comdat_distinct", comdat($h)
 
 ;; Test implicit section assignment for globals in the same comdat group.
-; CHECK: .section .rodata.cst4,"aGM",@progbits,4,i,comdat,unique,[[#U+12]]
+; CHECK: .section .rodata.cst4,"aGM",@progbits,4,i,comdat,unique,18
 ; CHECK: implicit_rodata_cst4_same_comdat:
-; CHECK: .section .rodata.cst8,"aGM",@progbits,8,i,comdat,unique,[[#U+13]]
+; CHECK: .section .rodata.cst8,"aGM",@progbits,8,i,comdat,unique,19
 ; CHECK: implicit_rodata_cst8_same_comdat:
 
 ;; Check that globals in the same comdat group that are explicitly assigned
 ;; to a section have been placed into distinct sections with the same name, but
 ;; different entry sizes. Due to the way that MC currently works the unique ID
 ;; does not have any effect here, although it appears in the assembly. The unique ID's
 ;; appear incorrect as comdats are not taken into account when looking up the unique ID
 ;; for a mergeable section. However, as they have no effect it doesn't matter that they
 ;; are incorrect.
-; CHECK: .section .explicit_comdat_same,"aM",@progbits,4,unique,[[#U+14]]
+; CHECK: .section .explicit_comdat_same,"aM",@progbits,4,unique,20
 ; CHECK: explicit_comdat_same_supply_uid:
-; CHECK: .section .explicit_comdat_same,"aGM",@progbits,4,i,comdat,unique,[[#U+15]]
+; CHECK: .section .explicit_comdat_same,"aGM",@progbits,4,i,comdat,unique,20
 ; CHECK: explicit_comdat_same1:
 ; CHECK: explicit_comdat_same2:
-; CHECK: .section .explicit_comdat_same,"aGM",@progbits,8,i,comdat,unique,[[#U+16]]
+; CHECK: .section .explicit_comdat_same,"aGM",@progbits,8,i,comdat,unique,21
 ; CHECK: explicit_comdat_same3:
 
 $i = comdat any
 
 @implicit_rodata_cst4_same_comdat = unnamed_addr constant [2 x i16] [i16 1, i16 1], comdat($i)
 @implicit_rodata_cst8_same_comdat = unnamed_addr constant [2 x i32] [i32 1, i32 1], comdat($i)
 
 @explicit_comdat_same_supply_uid = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_same"
 @explicit_comdat_same1 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_same", comdat($i)
 @explicit_comdat_same2 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit_comdat_same", comdat($i)
 @explicit_comdat_same3 = unnamed_addr constant [2 x i32] [i32 1, i32 1], section ".explicit_comdat_same", comdat($i)
 
 ;; Check interaction between symbols that are explicitly assigned
 ;; to a section and implicitly assigned symbols.
 
-; CHECK: .section .rodata.str1.1,"aMS",@progbits,1{{$}}
+; CHECK: .section .rodata.str1.1,"aMS",@progbits,1
 ; CHECK: implicit_rodata_str1_1:
 ; CHECK: explicit_implicit_1:
 
 ;; Assign a compatible global to an existing mergeable section created implicitly.
 @implicit_rodata_str1_1 = unnamed_addr constant [2 x i8] [i8 1, i8 0]
 @explicit_implicit_1 = unnamed_addr constant [2 x i8] [i8 1, i8 0], section ".rodata.str1.1"
 
-; CHECK: .section .rodata.str1.1,"a",@progbits,unique,[[#U+17]]
+; CHECK: .section .rodata.str1.1,"a",@progbits,unique,22
 ; CHECK: explicit_implicit_2:
 
 ;; Assign an incompatible symbol (non-mergeable) to an existing mergeable section created implicitly.
 @explicit_implicit_2 = constant [2 x i16] [i16 1, i16 1], section ".rodata.str1.1"
 
-; CHECK: .section .rodata.str1.1,"aMS",@progbits,1{{$}}
+; CHECK: .section .rodata.str1.1,"aMS",@progbits,1
 ; CHECK: explicit_implicit_3:
-; CHECK: .section .rodata.str1.1,"a",@progbits,unique,[[#U+17]]
+; CHECK: .section .rodata.str1.1,"a",@progbits,unique,22
 ; CHECK: explicit_implicit_4:
 
 ;; Assign compatible globals to the previously created sections.
 @explicit_implicit_3 = unnamed_addr constant [2 x i8] [i8 1, i8 0], section ".rodata.str1.1"
 @explicit_implicit_4 = constant [2 x i16] [i16 1, i16 1], section ".rodata.str1.1"
 
-; CHECK: .section .rodata.str2.2,"aMS",@progbits,2{{$}}
+; CHECK: .section .rodata.str2.2,"aMS",@progbits,2
 ; CHECK: explicit_implicit_5:
 ; CHECK: implicit_rodata_str2_2:
 
 ;; Implicitly assign a compatible global to an existing mergeable section created explicitly.
 @explicit_implicit_5 = unnamed_addr constant [2 x i16] [i16 1, i16 0], section ".rodata.str2.2"
 @implicit_rodata_str2_2 = unnamed_addr constant [2 x i16] [i16 1, i16 0]
 
 ;; Check the interaction with inline asm.
 
-; CHECK: .section .asm_mergeable1,"aMS",@progbits,2{{$}}
+; CHECK: .section .asm_mergeable1,"aMS",@progbits,2
 ; CHECK: explicit_asm_1:
-; CHECK: .section .asm_nonmergeable1,"a",@progbits{{$}}
+; CHECK: .section .asm_nonmergeable1,"a",@progbits
 ; CHECK: explicit_asm_2:
-; CHECK: .section .asm_mergeable1,"aM",@progbits,4,unique,[[#U+18]]
+; CHECK: .section .asm_mergeable1,"aM",@progbits,4,unique,23
 ; CHECK: explicit_asm_3:
-; CHECK: .section .asm_nonmergeable1,"aMS",@progbits,2,unique,[[#U+19]]
+; CHECK: .section .asm_nonmergeable1,"aMS",@progbits,2,unique,24
 ; CHECK: explicit_asm_4:
-; CHECK: .section .asm_mergeable2,"aM",@progbits,4,unique,[[#U+20]]
+; CHECK: .section .asm_mergeable2,"aM",@progbits,4,unique,25
 ; CHECK: explicit_asm_5:
-; CHECK: .section .asm_nonmergeable2,"aMS",@progbits,2,unique,[[#U+21]]
+; CHECK: .section .asm_nonmergeable2,"aMS",@progbits,2,unique,26
 ; CHECK: explicit_asm_6:
-; CHECK: .section .asm_mergeable2,"aMS",@progbits,2{{$}}
+; CHECK: .section .asm_mergeable2,"aMS",@progbits,2
 ; CHECK: explicit_asm_7:
-; CHECK: .section .asm_nonmergeable2,"a",@progbits{{$}}
+; CHECK: .section .asm_nonmergeable2,"a",@progbits
 ; CHECK: explicit_asm_8:
 
 module asm ".section .asm_mergeable1,\22aMS\22,@progbits,2"
 module asm ".section .asm_nonmergeable1,\22a\22,@progbits"
 module asm ".section .asm_mergeable2,\22aMS\22,@progbits,2"
 module asm ".section .asm_nonmergeable2,\22a\22,@progbits"
 
 ;; Assign compatible symbols to sections created using inline asm.
 @explicit_asm_1 = unnamed_addr constant [2 x i16] [i16 1, i16 0], section ".asm_mergeable1"
 @explicit_asm_2 = constant [2 x i16] [i16 1, i16 0], section ".asm_nonmergeable1"
 ;; Assign incompatible globals to the same sections.
 @explicit_asm_3 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".asm_mergeable1"
 @explicit_asm_4 = unnamed_addr constant [2 x i16] [i16 1, i16 0], section ".asm_nonmergeable1"
 
 ;; Assign incompatible globals to sections created using inline asm.
 @explicit_asm_5 = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".asm_mergeable2"
 @explicit_asm_6 = unnamed_addr constant [2 x i16] [i16 1, i16 0], section ".asm_nonmergeable2"
 ;; Assign compatible globals to the same sections.
 @explicit_asm_7 = unnamed_addr constant [2 x i16] [i16 1, i16 0], section ".asm_mergeable2"
 @explicit_asm_8 = constant [2 x i16] [i16 1, i16 0], section ".asm_nonmergeable2"
 
 ;; A .note.GNU-stack section is created implicitly. We add a check for this as we want to use
 ;; --implicit-check-not to reduce the number of checks in this file.
-; CHECK: .section ".note.GNU-stack","",@progbits{{$}}
+; CHECK: .section ".note.GNU-stack","",@progbits
 
 ;; --no-integrated-as avoids the use of ",unique," for compatibility with older binutils.
 
 ;; Error if an incompatible symbol is explicitly placed into a mergeable section.
 ; RUN: not llc < %s -mtriple=x86_64 --no-integrated-as -binutils-version=2.34 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=NO-I-AS-ERR
 ; NO-I-AS-ERR: error: Symbol 'explicit_default_1' from module '<stdin>' required a section with entry-size=0 but was placed in section '.rodata.cst16' with entry-size=16: Explicit assignment by pragma or attribute of an incompatible symbol to this section?
 ; NO-I-AS-ERR: error: Symbol 'explicit_default_4' from module '<stdin>' required a section with entry-size=0 but was placed in section '.debug_str' with entry-size=1: Explicit assignment by pragma or attribute of an incompatible symbol to this section?
 ; NO-I-AS-ERR: error: Symbol 'explicit_implicit_2' from module '<stdin>' required a section with entry-size=0 but was placed in section '.rodata.str1.1' with entry-size=1: Explicit assignment by pragma or attribute of an incompatible symbol to this section?
 ; NO-I-AS-ERR: error: Symbol 'explicit_implicit_4' from module '<stdin>' required a section with entry-size=0 but was placed in section '.rodata.str1.1' with entry-size=1: Explicit assignment by pragma or attribute of an incompatible symbol to this section?
 
 ;; For GNU as before 2.35,
 ;; Don't create mergeable sections for globals with an explicit section name.
 ; RUN: echo '@explicit = unnamed_addr constant [2 x i16] [i16 1, i16 1], section ".explicit"' > %t.no_i_as.ll
 ; RUN: llc < %t.no_i_as.ll -mtriple=x86_64 --no-integrated-as -binutils-version=2.34 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=NO-I-AS-OLD
-; NO-I-AS-OLD: .section .explicit,"a",@progbits{{$}}
+; NO-I-AS-OLD: .section .explicit,"a",@progbits
 ; RUN: llc < %t.no_i_as.ll -mtriple=x86_64 --no-integrated-as -binutils-version=2.35 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=NO-I-AS-NEW
 ; RUN: llc < %t.no_i_as.ll -mtriple=x86_64 --no-integrated-as -binutils-version=none 2>&1 \
 ; RUN:     | FileCheck %s --check-prefix=NO-I-AS-NEW
 ; NO-I-AS-NEW: .section .explicit,"aM",@progbits,4,unique,1

llvm/unittests/ExecutionEngine/Orc/RTDyldObjectLinkingLayerTest.cpp

 #include "gtest/gtest.h"
 #include <string>
 
 using namespace llvm;
 using namespace llvm::orc;
 
 namespace {
 
-// Returns whether a non-alloc section was passed to the memory manager.
+// Adds an object with a debug section to RuntimeDyld and then returns whether
+// the debug section was passed to the memory manager.
 static bool testSetProcessAllSections(std::unique_ptr<MemoryBuffer> Obj,
                                       bool ProcessAllSections) {
   class MemoryManagerWrapper : public SectionMemoryManager {
   public:
-    MemoryManagerWrapper(bool &NonAllocSeen) : NonAllocSeen(NonAllocSeen) {}
+    MemoryManagerWrapper(bool &DebugSeen) : DebugSeen(DebugSeen) {}
     uint8_t *allocateDataSection(uintptr_t Size, unsigned Alignment,
                                  unsigned SectionID, StringRef SectionName,
                                  bool IsReadOnly) override {
-      // We check for ".note.GNU-stack" here because it is currently the only
-      // non-alloc section seen in the module. If this changes in future any
-      // other non-alloc section would do here.
-      if (SectionName == ".note.GNU-stack")
-        NonAllocSeen = true;
+      if (SectionName == ".debug_str")
+        DebugSeen = true;
       return SectionMemoryManager::allocateDataSection(
           Size, Alignment, SectionID, SectionName, IsReadOnly);
     }
 
   private:
-    bool &NonAllocSeen;
+    bool &DebugSeen;
   };
 
-  bool NonAllocSectionSeen = false;
+  bool DebugSectionSeen = false;
 
   ExecutionSession ES(std::make_unique<UnsupportedExecutorProcessControl>());
   auto &JD = ES.createBareJITDylib("main");
   auto Foo = ES.intern("foo");
 
-  RTDyldObjectLinkingLayer ObjLayer(ES, [&NonAllocSectionSeen]() {
-    return std::make_unique<MemoryManagerWrapper>(NonAllocSectionSeen);
+  RTDyldObjectLinkingLayer ObjLayer(ES, [&DebugSectionSeen]() {
+    return std::make_unique<MemoryManagerWrapper>(DebugSectionSeen);
   });
 
   auto OnResolveDoNothing = [](Expected<SymbolMap> R) {
     cantFail(std::move(R));
   };
 
   ObjLayer.setProcessAllSections(ProcessAllSections);
   cantFail(ObjLayer.add(JD, std::move(Obj)));
   ES.lookup(LookupKind::Static, makeJITDylibSearchOrder(&JD),
             SymbolLookupSet(Foo), SymbolState::Resolved, OnResolveDoNothing,
             NoDependenciesToRegister);
 
   if (auto Err = ES.endSession())
     ES.reportError(std::move(Err));
 
-  return NonAllocSectionSeen;
+  return DebugSectionSeen;
 }
 
 TEST(RTDyldObjectLinkingLayerTest, TestSetProcessAllSections) {
   LLVMContext Context;
   auto M = std::make_unique<Module>("", Context);
   M->setTargetTriple("x86_64-unknown-linux-gnu");
-
-  // These values are only here to ensure that the module is non-empty.
-  // They are no longer relevant to the test.
   Constant *StrConstant = ConstantDataArray::getString(Context, "forty-two");
   auto *GV =
       new GlobalVariable(*M, StrConstant->getType(), true,
                          GlobalValue::ExternalLinkage, StrConstant, "foo");
   GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   GV->setAlignment(Align(1));
 
+  GV->setSection(".debug_str");
+
   // Initialize the native target in case this is the first unit test
   // to try to build a TM.
   OrcNativeTarget::initialize();
   std::unique_ptr<TargetMachine> TM(EngineBuilder().selectTarget(
       Triple(M->getTargetTriple()), "", "", SmallVector<std::string, 1>()));
   if (!TM)
     return;
 
   auto Obj = cantFail(SimpleCompiler(*TM)(*M));
 
   EXPECT_FALSE(testSetProcessAllSections(
       MemoryBuffer::getMemBufferCopy(Obj->getBuffer()), false))
-      << "Non-alloc section seen despite ProcessAllSections being false";
+      << "Debug section seen despite ProcessAllSections being false";
   EXPECT_TRUE(testSetProcessAllSections(std::move(Obj), true))
-      << "Expected to see non-alloc section when ProcessAllSections is true";
+      << "Expected to see debug section when ProcessAllSections is true";
 }
 
 TEST(RTDyldObjectLinkingLayerTest, TestOverrideObjectFlags) {
 
   OrcNativeTarget::initialize();
 
   std::unique_ptr<TargetMachine> TM(
       EngineBuilder().selectTarget(Triple("x86_64-unknown-linux-gnu"), "", "",