Always add a .note.GNU-stack section if -r.

[ruiu]

Summary

With this patch, lld creates a .note.GNU_stack and adds it to an
output file if it is creating a re-linkable object file (i.e. if -r
is given). If we don't do this, and if you use GNU linkers as a final
linker, they create an executable whose stack area is executable,
which is considered pretty bad these days.

[rprichard]

lld/ELF/SyntheticSections.h

142 ↗

(On Diff #163008)

I think we want to pass SHF_EXECINSTR as the first SyntheticSection param if Config->ZExecstack is set?

[ruiu]

It's intentionally omitted, as I think if you want an exectuable stack, you should explicitly pass -z execstack to the final linker.

[rprichard]

In D51400#1216968, @ruiu wrote:

It's intentionally omitted, as I think if you want an exectuable stack, you should explicitly pass -z execstack to the final linker.

Ok, that sounds reasonable.

The change looks OK to me.

lld/trunk/ELF/SyntheticSections.h

public:
   bool HasGotOffRel = false;
 
 protected:
   size_t NumEntries = 0;
   uint32_t TlsIndexOff = -1;
   uint64_t Size = 0;
 };
 
+// .note.GNU-stack section.
+class GnuStackSection : public SyntheticSection {
+public:
+  GnuStackSection()
+      : SyntheticSection(0, llvm::ELF::SHT_PROGBITS, 1, ".note.GNU-stack") {}
+  void writeTo(uint8_t *Buf) override {}
+  size_t getSize() const override { return 0; }
+};
+
 // .note.gnu.build-id section.
 class BuildIdSection : public SyntheticSection {
   // First 16 bytes are a header.
   static const unsigned HeaderSize = 16;
 
 public:
   BuildIdSection();
   void writeTo(uint8_t *Buf) override;

lld/trunk/ELF/Writer.cpp

InX::RelaIplt = make<RelocationSection<ELFT>>(
       false /*Sort*/);
   Add(InX::RelaIplt);
 
   InX::Plt = make<PltSection>(false);
   Add(InX::Plt);
   InX::Iplt = make<PltSection>(true);
   Add(InX::Iplt);
 
+  // .note.GNU-stack is always added when we are creating a re-linkable
+  // object file. Other linkers are using the presence of this marker
+  // section to control the executable-ness of the stack area, but that
+  // is irrelevant these days. Stack area should always be non-executable
+  // by default. So we emit this section unconditionally.
+  if (Config->Relocatable)
+    Add(make<GnuStackSection>());
+
   if (!Config->Relocatable) {
     if (Config->EhFrameHdr) {
       InX::EhFrameHdr = make<EhFrameHeader>();
       Add(InX::EhFrameHdr);
     }
     InX::EhFrame = make<EhFrameSection>();
     Add(InX::EhFrame);
   }

lld/trunk/test/ELF/relocatable-bss.s

 # CHECK-NEXT:    ABIVersion: 0
 # CHECK-NEXT:    Unused: (00 00 00 00 00 00 00)
 # CHECK-NEXT:  }
 # CHECK-NEXT:  Type: Relocatable
 # CHECK-NEXT:  Machine: EM_X86_64
 # CHECK-NEXT:  Version:
 # CHECK-NEXT:  Entry:
 # CHECK-NEXT:   ProgramHeaderOffset:
-# CHECK-NEXT:   SectionHeaderOffset: 0xD8
+# CHECK-NEXT:   SectionHeaderOffset: 0xE8
 # CHECK-NEXT:  Flags [
 # CHECK-NEXT:  ]
 # CHECK-NEXT:  HeaderSize:
 # CHECK-NEXT:  ProgramHeaderEntrySize:
 # CHECK-NEXT:  ProgramHeaderCount:
 # CHECK-NEXT:  SectionHeaderEntrySize:
 # CHECK-NEXT:  SectionHeaderCount:
 # CHECK-NEXT:  StringTableSectionIndex:

lld/trunk/test/ELF/relocatable-comdat-multiple.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/relocatable-comdat-multiple.s -o %t2.o
 # RUN: ld.lld -r %t.o %t2.o -o %t
 # RUN: llvm-readobj -elf-section-groups %t | FileCheck %s
 
 # CHECK:      Groups {
 # CHECK-NEXT:   Group {
 # CHECK-NEXT:     Name: .group
 # CHECK-NEXT:     Index: 2
-# CHECK-NEXT:     Link: 8
+# CHECK-NEXT:     Link: 9
 # CHECK-NEXT:     Info: 1
 # CHECK-NEXT:     Type: COMDAT
 # CHECK-NEXT:     Signature: aaa
 # CHECK-NEXT:     Section(s) in group [
 # CHECK-NEXT:       .text.a
 # CHECK-NEXT:       .text.b
 # CHECK-NEXT:     ]
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Group {
 # CHECK-NEXT:     Name: .group
 # CHECK-NEXT:     Index: 5
-# CHECK-NEXT:     Link: 8
+# CHECK-NEXT:     Link: 9
 # CHECK-NEXT:     Info: 6
 # CHECK-NEXT:     Type: COMDAT
 # CHECK-NEXT:     Signature: bbb
 # CHECK-NEXT:     Section(s) in group [
 # CHECK-NEXT:       .text.c
 # CHECK-NEXT:       .text.d
 # CHECK-NEXT:     ]
 # CHECK-NEXT:   }
 # CHECK-NEXT: }
 
 .section .text.a,"axG",@progbits,aaa,comdat
 .section .text.b,"axG",@progbits,aaa,comdat

lld/trunk/test/ELF/relocatable-comdat.s

 # CHECK-NEXT:   Address:
 # CHECK-NEXT:   Offset:
 # CHECK-NEXT:   Size: 4
 
 # CHECK:       Groups {
 # CHECK-NEXT:    Group {
 # CHECK-NEXT:      Name: .group
 # CHECK-NEXT:      Index: 2
-# CHECK-NEXT:      Link: 5
+# CHECK-NEXT:      Link: 6
 # CHECK-NEXT:      Info: 1 
 # CHECK-NEXT:      Type: COMDAT
 # CHECK-NEXT:      Signature: abc
 # CHECK-NEXT:      Section(s) in group [
 # CHECK-NEXT:        .text.bar
 # CHECK-NEXT:        .text.foo
 # CHECK-NEXT:      ]
 # CHECK-NEXT:    }
 # CHECK-NEXT:  }
 
 .section .text.bar,"axG",@progbits,abc,comdat
 .quad 42
 .section .text.foo,"axG",@progbits,abc,comdat
 .long 42

lld/trunk/test/ELF/relocatable-comdat2.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
 # RUN: ld.lld -r %t.o -o %t
 # RUN: llvm-readobj -elf-section-groups -s %t | FileCheck %s
 
 ## Check .foo was not merged.
 # CHECK: Sections [
 # CHECK:  Name: .foo
 # CHECK:  Name: .foo
 # CHECK:  Name: .foo
 
 # CHECK:      Groups {
 # CHECK-NEXT:   Group {
 # CHECK-NEXT:     Name: .group
 # CHECK-NEXT:     Index: 2
-# CHECK-NEXT:     Link: 7
+# CHECK-NEXT:     Link: 8
 # CHECK-NEXT:     Info: 1
 # CHECK-NEXT:     Type: COMDAT
 # CHECK-NEXT:     Signature: bar
 # CHECK-NEXT:     Section(s) in group [
 # CHECK-NEXT:       .foo (3)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:   }
 # CHECK-NEXT:   Group {
 # CHECK-NEXT:     Name: .group
 # CHECK-NEXT:     Index: 4
-# CHECK-NEXT:     Link: 7
+# CHECK-NEXT:     Link: 8
 # CHECK-NEXT:     Info: 2
 # CHECK-NEXT:     Type: COMDAT
 # CHECK-NEXT:     Signature: zed
 # CHECK-NEXT:     Section(s) in group [
 # CHECK-NEXT:       .foo (5)
 # CHECK-NEXT:     ]
 # CHECK-NEXT:   }
 # CHECK-NEXT: }
 
 .section .foo,"axG",@progbits,bar,comdat
 .section .foo,"axG",@progbits,zed,comdat
 .section .foo,"ax",@progbits

lld/trunk/test/ELF/relocatable-many-sections.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple x86_64-pc-linux-gnu %s -o %t.o
 # RUN: ld.lld -r %t.o -o %t
 
 ## Check we are able to link against relocatable file produced.
 # RUN: ld.lld %t -o %t.out
 
 ## Check we emit a valid ELF header when
 ## sections amount is greater than SHN_LORESERVE.
 # RUN: llvm-readobj -file-headers %t | FileCheck %s --check-prefix=HDR
 # HDR:      ElfHeader {
-# HDR:        SectionHeaderCount: 0 (65543)
-# HDR-NEXT:   StringTableSectionIndex: 65535 (65541)
+# HDR:        SectionHeaderCount: 0 (65544)
+# HDR-NEXT:   StringTableSectionIndex: 65535 (65542)
 
 ## Check that:
 ## 1) 65541 is the index of .shstrtab section.
 ## 2) .symtab_shndxr is linked with .symtab.
 ## 3) .symtab_shndxr entry size and alignment == 4.
 ## 4) .symtab_shndxr has size equal to
 ##    (sizeof(.symtab) / entsize(.symtab)) * entsize(.symtab_shndxr) = 0x4 * 0x180048 / 0x18 == 0x04000c
+
 # RUN: llvm-readelf -sections -symbols %t | FileCheck %s
-##              [Nr]    Name           Type                   Address          Off    Size   ES Flg  Lk    Inf    Al
-# CHECK:        [65538] .bar
-# CHECK-NEXT:   [65539] .symtab        SYMTAB                 0000000000000000 000040 180078 18      65542 65539  8
-# CHECK-NEXT:   [65540] .symtab_shndxr SYMTAB SECTION INDICES 0000000000000000 1800b8 040014 04      65539 0      4
-# CHECK-NEXT:   [65541] .shstrtab      STRTAB                 0000000000000000 1c00cc 0f0035 00      0     0      1
-# CHECK-NEXT:   [65542] .strtab        STRTAB                 0000000000000000 2b0101 00000c 00
+#        [Nr] Name              Type            Address          Off    Size   ES Flg Lk Inf Al
+# CHECK: [65539] .note.GNU-stack PROGBITS       0000000000000000 000040 000000 00      0   0  1
+# CHECK: [65540] .symtab        SYMTAB          0000000000000000 000040 180078 18     65543 65539  8
+# CHECK: [65541] .symtab_shndxr SYMTAB SECTION INDICES 0000000000000000 1800b8 040014 04     65540   0  4
+# CHECK: [65542] .shstrtab      STRTAB          0000000000000000 1c00cc 0f0045 00      0   0  1
+# CHECK: [65543] .strtab        STRTAB          0000000000000000 2b0111 00000c 00      0   0  1
+
 # 5) Check we are able to represent symbol foo with section (.bar) index  > 0xFF00 (SHN_LORESERVE).
 # CHECK: GLOBAL DEFAULT  65538 foo
 
 .macro gen_sections4 x
   .section a\x
   .section b\x
   .section c\x
   .section d\x

lld/trunk/test/ELF/relocatable.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/relocatable.s -o %t2.o
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/relocatable2.s -o %t3.o
 # RUN: ld.lld -r %t1.o %t2.o %t3.o -o %t
 # RUN: llvm-readobj -file-headers -sections -program-headers -symbols -r %t | FileCheck %s
+# RUN: llvm-objdump -section-headers %t | FileCheck -check-prefix=SECTION %s
 # RUN: llvm-objdump -s -d %t | FileCheck -check-prefix=CHECKTEXT %s
 
 ## Test --relocatable alias
 # RUN: ld.lld --relocatable %t1.o %t2.o %t3.o -o %t
 # RUN: llvm-readobj -file-headers -sections -program-headers -symbols -r %t | FileCheck %s
 # RUN: llvm-objdump -s -d %t | FileCheck -check-prefix=CHECKTEXT %s
 
 ## Verify that we can use our relocation output as input to produce executable

 # CHECK-NEXT:  ProgramHeaderOffset: 0x0
 # CHECK-NEXT:  SectionHeaderOffset:
 # CHECK-NEXT:  Flags [
 # CHECK-NEXT:  ]
 # CHECK-NEXT:  HeaderSize: 64
 # CHECK-NEXT:  ProgramHeaderEntrySize: 0
 # CHECK-NEXT:  ProgramHeaderCount: 0
 # CHECK-NEXT:  SectionHeaderEntrySize: 64
-# CHECK-NEXT:  SectionHeaderCount: 7
-# CHECK-NEXT:  StringTableSectionIndex: 5
+# CHECK-NEXT:  SectionHeaderCount: 8
+# CHECK-NEXT:  StringTableSectionIndex: 6
 # CHECK-NEXT:  }
 
 # CHECK:       Relocations [
 # CHECK-NEXT:  Section ({{.*}}) .rela.text {
 # CHECK-NEXT:    0x3 R_X86_64_32S x 0x0
 # CHECK-NEXT:    0xE R_X86_64_32S y 0x0
 # CHECK-NEXT:    0x23 R_X86_64_32S xx 0x0
 # CHECK-NEXT:    0x2E R_X86_64_32S yy 0x0
 # CHECK-NEXT:    0x43 R_X86_64_32S xxx 0x0
 # CHECK-NEXT:    0x4E R_X86_64_32S yyy 0x0
 # CHECK-NEXT:  }
 
+# SECTION: Sections:
+# SECTION: Idx Name          Size      Address          Type
+# SECTION:   0               00000000 0000000000000000
+# SECTION:   1 .text         00000056 0000000000000000 TEXT
+# SECTION:   2 .rela.text    00000090 0000000000000000
+# SECTION:   3 .bss          00000018 0000000000000000 BSS
+# SECTION:   4 .note.GNU-stack 00000000 0000000000000000
+# SECTION:   5 .symtab       00000168 0000000000000000
+# SECTION:   6 .shstrtab     00000041 0000000000000000
+# SECTION:   7 .strtab       0000002d 0000000000000000
+
 # CHECKTEXT:      Disassembly of section .text:
 # CHECKTEXT-NEXT: main:
 # CHECKTEXT-NEXT: 0: c7 04 25 00 00 00 00 05 00 00 00 movl $5, 0
 # CHECKTEXT-NEXT: b: c7 04 25 00 00 00 00 07 00 00 00 movl $7, 0
 # CHECKTEXT:      foo:
 # CHECKTEXT-NEXT: 20: c7 04 25 00 00 00 00 01 00 00 00 movl $1, 0
 # CHECKTEXT-NEXT: 2b: c7 04 25 00 00 00 00 02 00 00 00 movl $2, 0
 # CHECKTEXT:      bar: