[ELF] - Fill between executable sections with trap instructions

[grimar]

Summary

Currently, LLD leaves padding between executable sections as-is, so they are 0.
That is not desirable. Disassemblers would interpret the sequences of 0 bytes at
end of each function as machine instructions and print out bogus disassembly.

Patch adds filling of gaps between executable sections with one byte target
specific trap instruction.

This is PR32227.

[ruiu]

D30886 is already out. Besides that, I believe this has the same performance issue as that patch.

[grimar]

In D30901#699446, @ruiu wrote:

D30886 is already out. Besides that, I believe this has the same performance issue as that patch.

Ok, PR was free, I took it and did not notice that patch.

[grimar]

D30886 was first.

[jhenderson]

In D30901#700245, @grimar wrote:

In D30901#699446, @ruiu wrote:

D30886 is already out. Besides that, I believe this has the same performance issue as that patch.

Ok, PR was free, I took it and did not notice that patch.

Sorry, I don't have bugzilla access yet, so couldn't pick it up :)

[grimar]

In D30901#700364, @jhenderson wrote:

In D30901#700245, @grimar wrote:

In D30901#699446, @ruiu wrote:

D30886 is already out. Besides that, I believe this has the same performance issue as that patch.

Ok, PR was free, I took it and did not notice that patch.

Sorry, I don't have bugzilla access yet, so couldn't pick it up :)

It's okay :)

ELF/LinkerScript.h

struct OutputSectionCommand : BaseCommand {
 
   StringRef Name;
   Expr AddrExpr;
   Expr AlignExpr;
   Expr LMAExpr;
   Expr SubalignExpr;
   std::vector<std::unique_ptr<BaseCommand>> Commands;
   std::vector<StringRef> Phdrs;
-  uint32_t Filler = 0;
+  llvm::Optional<uint32_t> Filler;
   ConstraintKind Constraint = ConstraintKind::NoConstraint;
   std::string Location;
   std::string MemoryRegionName;
 };
 
 // This struct represents one section match pattern in SECTIONS() command.
 // It can optionally have negative match pattern for EXCLUDED_FILE command.
 // Also it may be surrounded with SORT() command, so contains sorting rules.
public:
   void addOrphanSections(OutputSectionFactory &Factory);
   void removeEmptyCommands();
   void adjustSectionsBeforeSorting();
   void adjustSectionsAfterSorting();
 
   std::vector<PhdrEntry> createPhdrs();
   bool ignoreInterpSection();
 
-  uint32_t getFiller(StringRef Name);
+  llvm::Optional<uint32_t> getFiller(StringRef Name);
   void writeDataBytes(StringRef Name, uint8_t *Buf);
   bool hasLMA(StringRef Name);
   bool shouldKeep(InputSectionBase *S);
   void assignOffsets(OutputSectionCommand *Cmd);
   void placeOrphanSections();
   void assignAddresses(std::vector<PhdrEntry> &Phdrs);
   bool hasPhdrsCommands();
   uint64_t getSymbolValue(const Twine &Loc, StringRef S) override;

ELF/LinkerScript.cpp

template <class ELFT> bool LinkerScript<ELFT>::ignoreInterpSection() {
   // Ignore .interp section in case we have PHDRS specification
   // and PT_INTERP isn't listed.
   return !Opt.PhdrsCommands.empty() &&
          llvm::find_if(Opt.PhdrsCommands, [](const PhdrsCommand &Cmd) {
            return Cmd.Type == PT_INTERP;
          }) == Opt.PhdrsCommands.end();
 }
 
-template <class ELFT> uint32_t LinkerScript<ELFT>::getFiller(StringRef Name) {
+template <class ELFT>
+Optional<uint32_t> LinkerScript<ELFT>::getFiller(StringRef Name) {
   for (const std::unique_ptr<BaseCommand> &Base : Opt.Commands)
     if (auto *Cmd = dyn_cast<OutputSectionCommand>(Base.get()))
       if (Cmd->Name == Name)
         return Cmd->Filler;
-  return 0;
+  return Optional<uint32_t>();
 }
 
 template <class ELFT>
 static void writeInt(uint8_t *Buf, uint64_t Data, uint64_t Size) {
   const endianness E = ELFT::TargetEndianness;
 
   switch (Size) {
   case 1:

ELF/OutputSections.cpp

void fill(uint8_t *Buf, size_t Size, uint32_t Filler) {
   uint8_t V[4];
   write32be(V, Filler);
   size_t I = 0;
   for (; I + 4 < Size; I += 4)
     memcpy(Buf + I, V, 4);
   memcpy(Buf + I, V, Size - I);
 }
 
+// Fills the gaps between sections, at first fills whole buffer
+// with target specific one-byte trap padding if section is executable.
+// That was done because we want to avoid bogus disassembly output which
+// happens if we do not fill gaps with specific nop trap instructions.
+// After above function applies linker script's fill expression which always
+// overrides default filling if present.
+template <class ELFT>
+static void fillSectionGaps(OutputSection *Sec, uint8_t *Buf) {
+  if (Sec->Flags & SHF_EXECINSTR)
+    memset(Buf, Target->PaddingValue, Sec->Size);
+  if (Optional<uint32_t> Filler = Script<ELFT>::X->getFiller(Sec->Name))
+    fill(Buf, Sec->Size, *Filler);
+}
+
 template <class ELFT> void OutputSection::writeTo(uint8_t *Buf) {
   Loc = Buf;
-  if (uint32_t Filler = Script<ELFT>::X->getFiller(this->Name))
-    fill(Buf, this->Size, Filler);
+  fillSectionGaps<ELFT>(this, Buf);
 
   auto Fn = [=](InputSection *IS) { IS->writeTo<ELFT>(Buf); };
   forEach(Sections.begin(), Sections.end(), Fn);
 
   // Linker scripts may have BYTE()-family commands with which you
   // can write arbitrary bytes to the output. Process them if any.
   Script<ELFT>::X->writeDataBytes(this->Name, Buf);
 }

ELF/SyntheticSections.cpp

 
 template <class ELFT>
 MipsRldMapSection<ELFT>::MipsRldMapSection()
     : SyntheticSection(SHF_ALLOC | SHF_WRITE, SHT_PROGBITS,
                        sizeof(typename ELFT::uint), ".rld_map") {}
 
 template <class ELFT> void MipsRldMapSection<ELFT>::writeTo(uint8_t *Buf) {
   // Apply filler from linker script.
-  uint64_t Filler = Script<ELFT>::X->getFiller(this->Name);
-  Filler = (Filler << 32) | Filler;
+  uint64_t Filler = 0;
+  if (Optional<uint32_t> F = Script<ELFT>::X->getFiller(this->Name))
+    Filler = ((uint64_t)*F << 32) | (uint64_t)*F;
   memcpy(Buf, &Filler, getSize());
 }
 
 template <class ELFT>
 ARMExidxSentinelSection<ELFT>::ARMExidxSentinelSection()
     : SyntheticSection(SHF_ALLOC | SHF_LINK_ORDER, SHT_ARM_EXIDX,
                        sizeof(typename ELFT::uint), ".ARM.exidx") {}
 

ELF/Target.h

public:
   virtual RelExpr getRelExpr(uint32_t Type, const SymbolBody &S) const = 0;
   virtual void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const = 0;
   virtual ~TargetInfo();
 
   unsigned TlsGdRelaxSkip = 1;
   unsigned PageSize = 4096;
   unsigned DefaultMaxPageSize = 4096;
 
+  // Used for filling gaps in executable sections. Assumed to be
+  // target specific one byte trap instruction.
+  uint8_t PaddingValue = 0x0;
+
   // On FreeBSD x86_64 the first page cannot be mmaped.
   // On Linux that is controled by vm.mmap_min_addr. At least on some x86_64
   // installs that is 65536, so the first 15 pages cannot be used.
   // Given that, the smallest value that can be used in here is 0x10000.
   uint64_t DefaultImageBase = 0x10000;
 
   uint32_t CopyRel;
   uint32_t GotRel;

ELF/Target.cpp

X86TargetInfo::X86TargetInfo() {
   TlsGotRel = R_386_TLS_TPOFF;
   TlsModuleIndexRel = R_386_TLS_DTPMOD32;
   TlsOffsetRel = R_386_TLS_DTPOFF32;
   GotEntrySize = 4;
   GotPltEntrySize = 4;
   PltEntrySize = 16;
   PltHeaderSize = 16;
   TlsGdRelaxSkip = 2;
+  PaddingValue = 0xcc;
 }
 
 RelExpr X86TargetInfo::getRelExpr(uint32_t Type, const SymbolBody &S) const {
   switch (Type) {
   case R_386_8:
   case R_386_16:
   case R_386_32:
   case R_386_TLS_LDO_32:
template <class ELFT> X86_64TargetInfo<ELFT>::X86_64TargetInfo() {
   TlsGotRel = R_X86_64_TPOFF64;
   TlsModuleIndexRel = R_X86_64_DTPMOD64;
   TlsOffsetRel = R_X86_64_DTPOFF64;
   GotEntrySize = 8;
   GotPltEntrySize = 8;
   PltEntrySize = 16;
   PltHeaderSize = 16;
   TlsGdRelaxSkip = 2;
+  PaddingValue = 0xcc;
   // Align to the large page size (known as a superpage or huge page).
   // FreeBSD automatically promotes large, superpage-aligned allocations.
   DefaultImageBase = 0x200000;
 }
 
 template <class ELFT>
 RelExpr X86_64TargetInfo<ELFT>::getRelExpr(uint32_t Type,
                                            const SymbolBody &S) const {

test/ELF/linkerscript/excludefile.s

 # REQUIRES: x86
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 # RUN:   %p/Inputs/include.s -o %t2
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux \
 # RUN:   %p/Inputs/notinclude.s -o %t3.notinclude
 
 # RUN: echo "SECTIONS {} " > %t.script
 # RUN: ld.lld -o %t --script %t.script %t1 %t2 %t3.notinclude
 # RUN: llvm-objdump -d %t | FileCheck %s
 
 # CHECK: Disassembly of section .text:
 # CHECK: _start:
 # CHECK-NEXT: :       48 c7 c0 3c 00 00 00    movq    $60, %rax
 # CHECK-NEXT: :       48 c7 c7 2a 00 00 00    movq    $42, %rdi
-# CHECK-NEXT: :       00 00   addb    %al, (%rax)
 # CHECK: _potato:
 # CHECK-NEXT: :       90      nop
 # CHECK-NEXT: :       90      nop
-# CHECK-NEXT: :       00 00   addb    %al, (%rax)
 # CHECK: tomato:
 # CHECK-NEXT: :       b8 01 00 00 00  movl    $1, %eax
 
 # RUN: echo "SECTIONS { .patatino : \
 # RUN: { KEEP(*(EXCLUDE_FILE(*notinclude) .text)) } }" \
 # RUN:  > %t.script
 # RUN: ld.lld -o %t4 --script %t.script %t1 %t2 %t3.notinclude
 # RUN: llvm-objdump -d %t4 | FileCheck %s --check-prefix=EXCLUDE
 
 # EXCLUDE: Disassembly of section .patatino:
 # EXCLUDE: _start:
 # EXCLUDE-NEXT: :       48 c7 c0 3c 00 00 00    movq    $60, %rax
 # EXCLUDE-NEXT: :       48 c7 c7 2a 00 00 00    movq    $42, %rdi
-# EXCLUDE-NEXT: :       00 00   addb    %al, (%rax)
 # EXCLUDE: _potato:
 # EXCLUDE-NEXT: :       90      nop
 # EXCLUDE-NEXT: :       90      nop
 # EXCLUDE: Disassembly of section .text:
 # EXCLUDE: tomato:
 # EXCLUDE-NEXT: :       b8 01 00 00 00  movl    $1, %eax
 
 .section .text
 .globl _start
 _start:
     mov $60, %rax
     mov $42, %rdi

test/ELF/linkerscript/sections-padding-exec.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+## Check that paddings of executable sections are filled with trap byte.
+# RUN: echo "SECTIONS { .exec : { *(.exec*) } }" > %t.script
+# RUN: ld.lld -o %t.out --script %t.script %t
+# RUN: llvm-objdump -s %t.out | FileCheck %s --check-prefix=EXEC
+# EXEC:      66cccccc cccccccc cccccccc cccccccc
+# EXEC-NEXT: 66
+
+## Non-executable sections are not affected.
+# RUN: echo "SECTIONS { .noexec : { *(.noexec*) } }" > %t2.script
+# RUN: ld.lld -o %t2.out --script %t2.script %t
+# RUN: llvm-objdump -s %t2.out | FileCheck %s --check-prefix=NOEXEC
+# NOEXEC:  0000 77000000 00000000 00000000 00000000
+# NOEXEC:  0010 77
+
+## Check that =fill expression still overrides the default filler.
+# RUN: echo "SECTIONS { .exec : { *(.exec*) }=0x11223344 }" > %t3.script
+# RUN: ld.lld -o %t3.out --script %t3.script %t
+# RUN: llvm-objdump -s %t3.out | FileCheck %s --check-prefix=OVERRIDE
+# OVERRIDE:      Contents of section .exec:
+# OVERRIDE-NEXT:  0000 66223344 11223344 11223344 11223344
+# OVERRIDE-NEXT:  0010 66  
+
+.section        .exec.1,"ax"
+.align  16
+.byte   0x66
+
+.section        .exec.2,"ax"
+.align  16
+.byte   0x66
+
+.section        .noexec.1,"a"
+.align  16
+.byte   0x77
+
+.section        .noexec.2,"a"
+.align  16
+.byte   0x77

test/ELF/sections-padding-exec-i686.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=i686-pc-linux %s -o %t
+
+## Check that paddings of executable sections are filled with trap byte.
+# RUN: ld.lld -o %t.out %t
+# RUN: llvm-objdump -s %t.out | FileCheck %s
+# CHECK: Contents of section .text:
+# CHECK-NEXT: 66cccccc cccccccc cccccccc cccccccc
+# CHECK-NEXT: 66
+
+.section        .text.1,"ax"
+.align  16
+.byte   0x66
+
+.section        .text.2,"ax"
+.align  16
+.byte   0x66

test/ELF/sections-padding-exec.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+## Check that paddings of executable sections are filled with trap byte.
+# RUN: ld.lld -o %t.out %t
+# RUN: llvm-objdump -s %t.out | FileCheck %s
+# CHECK: Contents of section .text:
+# CHECK-NEXT: 66cccccc cccccccc cccccccc cccccccc
+# CHECK-NEXT: 66
+
+.section        .text.1,"ax"
+.align  16
+.byte   0x66
+
+.section        .text.2,"ax"
+.align  16
+.byte   0x66