[ELF] - Allow to combine sections of type SHT_NOTE with different attributes.

[grimar]

Summary

One of linux scripts (arch/x86/kernel/vmlinux.lds) has next line:

.notes : AT(ADDR(.notes) - 0xffffffff80000000) { __start_notes = .; *(.note.*) __stop_notes = .; } :text :note

when built with --build-id, we create allocatable .note.gnu.build-id, what is fine.
And another .note.* section which script wants to combine is non-allocatable and we error out.

Patch allows combining note sections with different flags.

[gbreynoo]

This looks great but I think the comment could be made clearer:

If sections are of the SHT_NOTE type we allow them to be combined, even if flags are incompatible. As an example, some scripts from the linux kernal combine allocatable and non-allocatbale SHT_NOTE sections together.

[grimar]

In D29324#661518, @gbreynoo wrote:

This looks great but I think the comment could be made clearer:

If sections are of the SHT_NOTE type we allow them to be combined, even if flags are incompatible. As an example, some scripts from the linux kernal combine allocatable and non-allocatbale SHT_NOTE sections together.

Ok, I'll change this comment in new diff or before commit (if this patch be approved). Thanks !

[grimar]

Issue of linux kernel. Abandoning for now.

[grimar]

Possible workaround for linux kernel is
change include/linux/elfnote.h to:

#define ELFNOTE(name, type, desc)               \
        ELFNOTE_START(name, type, "a")          \
                desc                    ;       \
        ELFNOTE_END

ELF/OutputSections.cpp

OutputSectionFactory<ELFT>::create(InputSectionBase<ELFT> *C,
   SectionKey Key = createKey(C, OutsecName);
   return create(Key, C);
 }
 
 static uint64_t getIncompatibleFlags(uint64_t Flags) {
   return Flags & (SHF_ALLOC | SHF_TLS);
 }
 
+template <class ELFT>
+static void checkFlagsCompatibility(OutputSectionBase *OS,
+                                    InputSectionBase<ELFT> *C) {
+  uint64_t OutSecFlags = getIncompatibleFlags(OS->Flags);
+  uint64_t Flags = getIncompatibleFlags(C->Flags);
+  if (OutSecFlags == Flags)
+    return;
+
+  // If flags incompatible, we still allow to combine them
+  // if sections is a type of SHT_NOTE. As an example
+  // some scripts from linux kernel combines allocatable
+  // and non-allocatable SHT_NOTE section together.
+  if (C->Type == SHT_NOTE)
+    return;
+
+  error("Section has flags incompatible with others with the same name " +
+        toString(C));
+}
+
 // We allow sections of types listed below to merged into a
 // single progbits section. This is typically done by linker
 // scripts. Merging nobits and progbits will force disk space
 // to be allocated for nobits sections. Other ones don't require
 // any special treatment on top of progbits, so there doesn't
 // seem to be a harm in merging them.
 static bool canMergeToProgbits(unsigned Type) {
   return Type == SHT_NOBITS || Type == SHT_PROGBITS || Type == SHT_INIT_ARRAY ||
          Type == SHT_PREINIT_ARRAY || Type == SHT_FINI_ARRAY ||
          Type == SHT_NOTE;
 }
 
 template <class ELFT>
 std::pair<OutputSectionBase *, bool>
 OutputSectionFactory<ELFT>::create(const SectionKey &Key,
                                    InputSectionBase<ELFT> *C) {
   uintX_t Flags = getOutFlags(C);
   OutputSectionBase *&Sec = Map[Key];
   if (Sec) {
-    if (getIncompatibleFlags(Sec->Flags) != getIncompatibleFlags(C->Flags))
-      error("Section has flags incompatible with others with the same name " +
-            toString(C));
+    checkFlagsCompatibility(Sec, C);
     if (Sec->Type != C->Type) {
       if (canMergeToProgbits(Sec->Type) && canMergeToProgbits(C->Type))
         Sec->Type = SHT_PROGBITS;
       else
         error("Section has different type from others with the same name " +
               toString(C));
     }
     Sec->Flags |= Flags;

test/ELF/incompatible-section-flags-notes.s

+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+# RUN: echo "SECTIONS { .notes : { *(.note.*) } }" > %t.script
+# RUN: ld.lld --script %t.script --build-id %t.o -o %t
+
+## Check that synthetic allocatable note section ".note.gnu.build-id"
+## links fine with non-allocatable .note.1
+.section .note.1, "", @note
+.quad 0