[ELF] Change default output section type to SHT_NOBITS

[jakehehrlich]

Summary

When an output section has no byte commands and has no input sections then it would be ideal if the type of the section is SHT_NOBITS so that the file can take up less space. This change sets the default type of of output sections to SHT_NOBITS instead of SHT_PROGBITS to allow this. This required some minor test changes (which double as tests for this new behavior) but extend-pt-load.s had be changed in a non-trivial way. Since it seems to me that the point of the test is to point out the consequences of how flags are assigned to output sections that don't have input sections I changed the test to work and still show how the memsize of the executable segment was changed.

[ruiu]

LGTM. Nice!

ELF/OutputSections.cpp

315–318 ↗

(On Diff #126413)

You are not using Data so it should be

if (isa<ByteCommand>(Base) && Type == SHT_NOBITS)
  Type = SHT_PROGBITS;

lld/trunk/ELF/LinkerScript.cpp

 OutputSection *LinkerScript::createOutputSection(StringRef Name,
                                                  StringRef Location) {
   OutputSection *&SecRef = NameToOutputSection[Name];
   OutputSection *Sec;
   if (SecRef && SecRef->Location.empty()) {
     // There was a forward reference.
     Sec = SecRef;
   } else {
-    Sec = make<OutputSection>(Name, SHT_PROGBITS, 0);
+    Sec = make<OutputSection>(Name, SHT_NOBITS, 0);
     if (!SecRef)
       SecRef = Sec;
   }
   Sec->Location = Location;
   return Sec;
 }
 
 OutputSection *LinkerScript::getOrCreateOutputSection(StringRef Name) {

lld/trunk/ELF/OutputSections.cpp

template <class ELFT> void OutputSection::finalize() {
   std::vector<InputSection *> Sections;
   for (BaseCommand *Base : SectionCommands) {
     if (auto *ISD = dyn_cast<InputSectionDescription>(Base)) {
       for (InputSection *&IS : ISD->Sections) {
         ScriptSections.push_back(&IS);
         Sections.push_back(IS);
       }
     }
+    if (isa<ByteCommand>(Base) && Type == SHT_NOBITS)
+      Type = SHT_PROGBITS;
   }
 
   if (Flags & SHF_LINK_ORDER) {
     std::stable_sort(Sections.begin(), Sections.end(), compareByFilePosition);
     for (int I = 0, N = Sections.size(); I < N; ++I)
       *ScriptSections[I] = Sections[I];
 
     // We must preserve the link order dependency of sections with the

lld/trunk/test/ELF/linkerscript/arm-exidx-order.s

 # REQUIRES: arm
 # RUN: llvm-mc -filetype=obj -triple=armv7a-none-linux-gnueabi %s -o %t.o
 # RUN: echo "SECTIONS { . = SIZEOF_HEADERS;    \
 # RUN:         .ARM.exidx : { *(.ARM.exidx*) } \
 # RUN:         .foo : { _foo = 0; } }" > %t.script
 # RUN: ld.lld -T %t.script %t.o -shared -o %t.so
 # RUN: llvm-readobj -s %t.so | FileCheck %s
 
 # CHECK:      Section {
 # CHECK:        Index: 
 # CHECK:        Name: .foo
-# CHECK-NEXT:   Type: SHT_PROGBITS
+# CHECK-NEXT:   Type: SHT_NOBITS
 # CHECK-NEXT:   Flags [
 # CHECK-NEXT:     SHF_ALLOC
 # CHECK-NEXT:   ]
 
 .fnstart
 .cantunwind
 .fnend

lld/trunk/test/ELF/linkerscript/extend-pt-load.s

 # cover the padding bits created by ALIGN.
 
 # RUN: echo "SECTIONS { \
 # RUN:  . = SIZEOF_HEADERS; \
 # RUN:  .dynsym : {  } \
 # RUN:  .hash : {  } \
 # RUN:  .dynstr : {  } \
 # RUN:  .text : { *(.text) } \
-# RUN:  . = ALIGN(0x1000); \
-# RUN:  bar : { HIDDEN(bar_sym = .); } \
+# RUN:  bar : { . = ALIGN(0x1000); } \
 # RUN:  .data.rel.ro : { *(.data.rel.ro) } \
 # RUN: }" > %t.script
 # RUN: ld.lld --hash-style=sysv -o %t2 --script %t.script %t.o -shared
 # RUN: llvm-readobj --elf-output-style=GNU -l -s %t2 | FileCheck --check-prefix=CHECK2 %s
 
 # CHECK2:      .text        PROGBITS 00000000000001bc 0001bc 000001 00 AX
-# CHECK2-NEXT: bar          PROGBITS 0000000000001000 001000 000000 00 AX
+# CHECK2-NEXT: bar          NOBITS   00000000000001bd 0001bd 000e43 00 AX
 # CHECK2-NEXT: .data.rel.ro PROGBITS 0000000000001000 001000 000001 00 WA
 
-# CHECK2:      LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x001000 0x001000 R E
+# CHECK2:      LOAD 0x000000 0x0000000000000000 0x0000000000000000 0x0001bd 0x001000 R E
 # CHECK2-NEXT: LOAD 0x001000 0x0000000000001000 0x0000000000001000 0x000068 0x000068 RW
 
 # If the current behavior becomes a problem we should consider just moving the commands out
 # of the section. That is, handle the above like the following test.
 
 # RUN: echo "SECTIONS { \
 # RUN:  . = SIZEOF_HEADERS; \
 # RUN:  .dynsym : {  } \

lld/trunk/test/ELF/linkerscript/merge-sections.s

 # 0x19E = begin + sizeof(.foo) = 0x190 + 0xE
 # CHECK-NEXT: Value: 0x19E
 
 # Check that we don't crash with --gc-sections
 # RUN: ld.lld --gc-sections -o %t2 --script %t.script %t -shared
 # RUN: llvm-readobj -s -t %t2 | FileCheck %s --check-prefix=GC
 
 # GC:        Name: .foo
-# GC-NEXT:   Type: SHT_PROGBITS
+# GC-NEXT:   Type: SHT_NOBITS
 # GC-NEXT:   Flags [
 # GC-NEXT:     SHF_ALLOC
 # GC-NEXT:   ]
 
 .section        .foo.1a,"aMS",@progbits,1
 .asciz "foo"
 
 .section        .foo.1b,"aMS",@progbits,1

lld/trunk/test/ELF/linkerscript/symbol-only-flags.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t.o
 # RUN: echo "SECTIONS { . = SIZEOF_HEADERS; \
 # RUN:         .tbss : { *(.tbss) }         \
 # RUN:         .foo : { bar = .; } }" > %t.script
 # RUN: ld.lld -o %t --script %t.script %t.o
 # RUN: llvm-readobj -s %t | FileCheck %s
 
 ## Check .foo does not get SHF_TLS flag.
 # CHECK:     Section {
 # CHECK:       Index:
 # CHECK:       Name: .foo
-# CHECK-NEXT:  Type: SHT_PROGBITS
+# CHECK-NEXT:  Type: SHT_NOBITS
 # CHECK-NEXT:  Flags [
 # CHECK-NEXT:    SHF_ALLOC
 # CHECK-NEXT:    SHF_WRITE
 # CHECK-NEXT:  ]
 
 .section .tbss,"awT",@nobits
 .quad 0

lld/trunk/test/ELF/linkerscript/symbol-only.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 
 # RUN: echo "SECTIONS { \
 # RUN:  . = SIZEOF_HEADERS; \
 # RUN:  abc : { foo = .; } \
 # RUN:  . = ALIGN(0x1000); \
 # RUN:  bar : { *(bar) } \
 # RUN: }" > %t.script
 # RUN: ld.lld -o %t1 --script %t.script %t -shared
 # RUN: llvm-objdump -section-headers -t %t1 | FileCheck %s
 # CHECK:      Sections:
 # CHECK-NEXT: Idx Name          Size      Address
 # CHECK-NEXT:   0               00000000 0000000000000000
-# CHECK:          abc           00000000 [[ADDR:[0-9a-f]*]] DATA
+# CHECK:          abc           00000000 [[ADDR:[0-9a-f]*]] BSS
 # CHECK-NEXT:     bar           00000000 0000000000001000 DATA
 
 # CHECK: SYMBOL TABLE:
 # CHECK:     [[ADDR]]         abc                00000000 foo
 
 .section bar, "a"