[ELF] Define symbols "_end" and "end" if referenced.

[ikudrin]

Summary

These symbols are expected to point to the end of the data segment.

Implements http://llvm.org/pr25528.

[davide]

This one looks fine, thanks. Testcases can be shrunk a little bit, e.g. you don't need to check the flags of BSS, that's covered somewhere else.

[ruiu]

ELF/Writer.cpp

629–630 ↗

(On Diff #40678)

I don't think it is unfortunate but naturally needed. Any logic to bin sections into segments affects the end position of .bss segment. It cannot be predicted here. (Otherwise we can construct segments right here instead of later.) I'd remove "Unfortunately."

633 ↗

(On Diff #40678)

Move this to initSymbols in Symbols.cpp.

640 ↗

(On Diff #40678)

It is a little bit alarming to use dyn_cast_or_null without using its return value, but I don't think we have isa_or_null. I'd probably write this way.

if (SymbolBody *B = Symtab.find("end"))
  if (isa<Undefined<ELFT>>(B))
    Symtab.addAbsoluteSym...

641 ↗

(On Diff #40678)

So we define two symbols, end and _end, but we use only one SymbolBody. Cool.

[emaste]

For reference http://llvm.org/pr25528

[ikudrin]

In D14833#293101, @davide wrote:

Testcases can be shrunk a little bit, e.g. you don't need to check the flags of BSS, that's covered somewhere else.

It's the only way I know to reach the lines like "Address:" and "Size:" and be sure that they are from the desired section.

[davide]

test/ELF/end-update.s

10 ↗

(On Diff #40678)

This can be removed.

test/ELF/end.s

12 ↗

(On Diff #40678)

This can be removed. Same for all the others (I think)

13 ↗

(On Diff #40678)

This can be removed.

[davide]

hmm, for some reason phabricator doesn't put my comment at the correct
line. When I say this can be removed I mean "type"

e.g.

+// DEFAULT-NEXT: Type: SHT_NOBITS

[ruiu]

For reference, please add "Implements http://llvm.org/pr25528" to
the commit message.

[ikudrin]

• Removed unnecessary flags from tests.
• Moved initialization of the End variable to the right place.
• Updated conditional statement.
• Corrected comments.

[ikudrin]

ELF/Writer.cpp

641 ↗

(On Diff #40685)

Not exactly. They only share the content.

[ruiu]

LGTM with nits.

ELF/Symbols.cpp

90 ↗

(On Diff #40685)

Sort.

ELF/Writer.cpp

899 ↗

(On Diff #40685)

them -> they

[davide]

I want to mention that gold keeps at least _end even if not referenced. I'm not sure what's the rationale behind that but something you may want to keep in mind.

[ikudrin]

In D14833#293217, @davide wrote:

I want to mention that gold keeps at least _end even if not referenced. I'm not sure what's the rationale behind that but something you may want to keep in mind.

Let's wait until the real case emerges. As far as I know, we don't expose symbols unless we know the case where they are required. For example, we don't add a well-known symbol "_GLOBAL_OFFSET_TABLE_", just use the corresponding value during calculation of relocations instead.

ELF/Writer.cpp

899 ↗

(On Diff #40685)

Oh, thanks!

lld/trunk/ELF/Symbols.h

 
 template <class ELFT> class DefinedAbsolute : public Defined<ELFT> {
   typedef ELFSymbolBody<ELFT> Base;
   typedef typename Base::Elf_Sym Elf_Sym;
 
 public:
   static Elf_Sym IgnoreUndef;
 
+  // The following symbols must be added early to reserve their places
+  // in symbol tables. The value of the symbols are set when all sections
+  // are finalized and their addresses are determined.
+
+  // The content for _end and end symbols.
+  static Elf_Sym End;
+
   // The content for _gp symbol for MIPS target.
-  // The symbol has to be added early to reserve a place in symbol tables.
-  // The value of the symbol is computed later by Writer.
   static Elf_Sym MipsGp;
 
   DefinedAbsolute(StringRef N, const Elf_Sym &Sym)
       : Defined<ELFT>(Base::DefinedAbsoluteKind, N, Sym) {}
 
   static bool classof(const SymbolBody *S) {
     return S->kind() == Base::DefinedAbsoluteKind;
   }
 };
 
 template <class ELFT>
 typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::IgnoreUndef;
 
 template <class ELFT>
+typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::End;
+
+template <class ELFT>
 typename DefinedAbsolute<ELFT>::Elf_Sym DefinedAbsolute<ELFT>::MipsGp;
 
 template <class ELFT> class DefinedCommon : public Defined<ELFT> {
   typedef ELFSymbolBody<ELFT> Base;
   typedef typename Base::Elf_Sym Elf_Sym;
 
 public:
   typedef typename llvm::object::ELFFile<ELFT>::uintX_t uintX_t;

lld/trunk/ELF/Symbols.cpp

std::unique_ptr<InputFile> Lazy::getMember() {
   // read from the library.
   if (MBRef.getBuffer().empty())
     return std::unique_ptr<InputFile>(nullptr);
 
   return createELFFile<ObjectFile>(MBRef);
 }
 
 template <class ELFT> static void doInitSymbols() {
+  DefinedAbsolute<ELFT>::End.setBinding(STB_GLOBAL);
   DefinedAbsolute<ELFT>::IgnoreUndef.setBinding(STB_WEAK);
   DefinedAbsolute<ELFT>::IgnoreUndef.setVisibility(STV_HIDDEN);
   Undefined<ELFT>::Optional.setVisibility(STV_HIDDEN);
 }
 
 void lld::elf2::initSymbols() {
   doInitSymbols<ELF32LE>();
   doInitSymbols<ELF32BE>();
   doInitSymbols<ELF64LE>();
   doInitSymbols<ELF64BE>();
 }
 
 template int SymbolBody::compare<ELF32LE>(SymbolBody *Other);
 template int SymbolBody::compare<ELF32BE>(SymbolBody *Other);
 template int SymbolBody::compare<ELF64LE>(SymbolBody *Other);
 template int SymbolBody::compare<ELF64BE>(SymbolBody *Other);

lld/trunk/ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::createSections() {
 
   // __tls_get_addr is defined by the dynamic linker for dynamic ELFs. For
   // static linking the linker is required to optimize away any references to
   // __tls_get_addr, so it's not defined anywhere. Create a hidden definition
   // to avoid the undefined symbol error.
   if (!isOutputDynamic())
     Symtab.addIgnoredSym("__tls_get_addr");
 
+  // If the "_end" symbol is referenced, it is expected to point to the address
+  // right after the data segment. Usually, this symbol points to the end
+  // of .bss section or to the end of .data section if .bss section is absent.
+  // The order of the sections can be affected by linker script,
+  // so it is hard to predict which section will be the last one.
+  // So, if this symbol is referenced, we just add the placeholder here
+  // and update its value later.
+  if (Symtab.find("_end"))
+    Symtab.addAbsoluteSym("_end", DefinedAbsolute<ELFT>::End);
+
+  // If there is an undefined symbol "end", we should initialize it
+  // with the same value as "_end". In any other case it should stay intact,
+  // because it is an allowable name for a user symbol.
+  if (SymbolBody *B = Symtab.find("end"))
+    if (B->isUndefined())
+      Symtab.addAbsoluteSym("end", DefinedAbsolute<ELFT>::End);
+
   // Scan relocations. This must be done after every symbol is declared so that
   // we can correctly decide if a dynamic relocation is needed.
   for (const std::unique_ptr<ObjectFile<ELFT>> &F : Symtab.getObjectFiles()) {
     for (InputSectionBase<ELFT> *C : F->getSections()) {
       if (isDiscarded(C))
         continue;
       if (auto *S = dyn_cast<InputSection<ELFT>>(C))
         scanRelocs(*S);
if (Interp) {
     Interp->p_type = PT_INTERP;
     copyPhdr(Interp, Out<ELFT>::Interp);
   }
 
   // Add space for section headers.
   SectionHeaderOff = RoundUpToAlignment(FileOff, ELFT::Is64Bits ? 8 : 4);
   FileSize = SectionHeaderOff + getNumSections() * sizeof(Elf_Shdr);
 
+  // Update "_end" and "end" symbols so that they
+  // point to the end of the data segment.
+  DefinedAbsolute<ELFT>::End.st_value = VA;
+
   // Update MIPS _gp absolute symbol so that it points to the static data.
   if (Config->EMachine == EM_MIPS)
     DefinedAbsolute<ELFT>::MipsGp.st_value = getMipsGpAddr<ELFT>();
 }
 
 // Returns the number of PHDR entries.
 template <class ELFT> int Writer<ELFT>::getPhdrsNum() const {
   bool Tls = false;

lld/trunk/test/ELF/end-preserve.s

+// Should preserve the value of the "end" symbol if it is defined.
+// REQUIRES: x86
+
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: ld.lld %t.o -o %t
+// RUN: llvm-nm %t | FileCheck %s
+
+// CHECK: 0000000000000005 A end
+
+.global _start,end
+end = 5
+.text
+_start:
+    nop
+.bss
+    .space 6

lld/trunk/test/ELF/end-update.s

+// Should set the value of the "end" symbol if it is undefined.
+// REQUIRES: x86
+
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+// RUN: ld.lld %t.o -o %t
+// RUN: llvm-readobj -sections -symbols %t | FileCheck %s
+
+// CHECK: Sections [
+// CHECK:     Name: .bss
+// CHECK-NEXT:     Type:
+// CHECK-NEXT:     Flags [
+// CHECK-NEXT:       SHF_ALLOC
+// CHECK-NEXT:       SHF_WRITE
+// CHECK-NEXT:     ]
+// CHECK-NEXT:     Address: 0x12000
+// CHECK-NEXT:     Offset:
+// CHECK-NEXT:     Size: 6
+// CHECK: ]
+// CHECK: Symbols [
+// CHECK:     Name: end
+// CHECK-NEXT:     Value: 0x12006
+// CHECK: ]
+
+.global _start,end
+.text
+_start:
+    nop
+.bss
+    .space 6

lld/trunk/test/ELF/end.s

+// Should set the value of the "_end" symbol to the end of the data segment.
+// REQUIRES: x86
+
+// RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %s -o %t.o
+
+// By default, the .bss section is the latest section of the data segment.
+// RUN: ld.lld %t.o -o %t
+// RUN: llvm-readobj -sections -symbols %t | FileCheck %s --check-prefix=DEFAULT
+
+// DEFAULT: Sections [
+// DEFAULT:     Name: .bss
+// DEFAULT-NEXT:     Type:
+// DEFAULT-NEXT:     Flags [
+// DEFAULT-NEXT:       SHF_ALLOC
+// DEFAULT-NEXT:       SHF_WRITE
+// DEFAULT-NEXT:     ]
+// DEFAULT-NEXT:     Address: 0x12002
+// DEFAULT-NEXT:     Offset:
+// DEFAULT-NEXT:     Size: 6
+// DEFAULT: ]
+// DEFAULT: Symbols [
+// DEFAULT:     Name: _end
+// DEFAULT-NEXT:     Value: 0x12008
+// DEFAULT: ]
+
+// If there is no .bss section, "_end" should point to the end of the .data section.
+// RUN: echo "SECTIONS { \
+// RUN:          /DISCARD/ : { *(.bss) } }" > %t.script
+// RUN: ld.lld %t.o --script %t.script -o %t
+// RUN: llvm-readobj -sections -symbols %t | FileCheck %s --check-prefix=NOBSS
+
+// NOBSS: Sections [
+// NOBSS:     Name: .data
+// NOBSS-NEXT:     Type:
+// NOBSS-NEXT:     Flags [
+// NOBSS-NEXT:       SHF_ALLOC
+// NOBSS-NEXT:       SHF_WRITE
+// NOBSS-NEXT:     ]
+// NOBSS-NEXT:     Address: 0x12000
+// NOBSS-NEXT:     Offset:
+// NOBSS-NEXT:     Size: 2
+// NOBSS: ]
+// NOBSS: Symbols [
+// NOBSS:     Name: _end
+// NOBSS-NEXT:     Value: 0x12002
+// NOBSS: ]
+
+// If the layout of the sections is changed, "_end" should point to the end of allocated address space.
+// RUN: echo "SECTIONS { \
+// RUN:          .bss : { *(.bss) } \
+// RUN:          .data : { *(.data) } \
+// RUN:          .text : { *(.text) } }" > %t.script
+// RUN: ld.lld %t.o --script %t.script -o %t
+// RUN: llvm-readobj -sections -symbols %t | FileCheck %s --check-prefix=TEXTATEND
+
+// TEXTATEND: Sections [
+// TEXTATEND:     Name: .text
+// TEXTATEND-NEXT:     Type:
+// TEXTATEND-NEXT:     Flags [
+// TEXTATEND-NEXT:       SHF_ALLOC
+// TEXTATEND-NEXT:       SHF_EXECINSTR
+// TEXTATEND-NEXT:     ]
+// TEXTATEND-NEXT:     Address: 0x12000
+// TEXTATEND-NEXT:     Offset:
+// TEXTATEND-NEXT:     Size: 1
+// TEXTATEND: ]
+// TEXTATEND: Symbols [
+// TEXTATEND:     Name: _end
+// TEXTATEND-NEXT:     Value: 0x12001
+// TEXTATEND: ]
+
+.global _start,_end
+.text
+_start:
+    nop
+.data
+    .word 1
+.bss
+    .space 6

lld/trunk/test/ELF/entry.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t1
 # RUN: not ld.lld %t1 -o %t2
-# RUN: ld.lld %t1 -o %t2 -e _end
+# RUN: ld.lld %t1 -o %t2 -e entry
 
 # RUN: ld.lld %t1 -o %t2 -e 4096
 # RUN: llvm-readobj -file-headers %t2 | FileCheck -check-prefix=DEC %s
 # RUN: ld.lld %t1 -o %t2 -e 0xcafe
 # RUN: llvm-readobj -file-headers %t2 | FileCheck -check-prefix=HEX %s
 # RUN: ld.lld %t1 -o %t2 -e 0777
 # RUN: llvm-readobj -file-headers %t2 | FileCheck -check-prefix=OCT %s
 
 # DEC: Entry: 0x1000
 # HEX: Entry: 0xCAFE
 # OCT: Entry: 0x1FF
 
-.globl _end
-_end:
+.globl entry
+entry: