[ELF] Default to entry address 0x0 in case start symbol is not defined and entry point is not specified in command line

[evgeny777]

Summary

The default behavior of GNU linkers is to set entry address to 0x0 when there is no start symbol (_start) and entry point is not passed to linker in command line arguments. Unfortunately lld reports undefined symbol error in this case (undefined symbol _start) and fails to link the program. An alternative is to always pass -Wl,-e,0 (or "-e 0"), which is not very convenient.

[emaste]

I'm not opposed to this but I am curious about the use case for binaries with entry 0 -- do you have a sample consumer?

[ruiu]

ELF/Driver.cpp

577–578

Can you move this after the code adding files to the symbol table? Once you add all files to the symbol table, you know whether _start is resolvable or not, so you can add an undefined symbol _start only when available. In that way, I think you can remove ForcedEntry variable.

[evgeny777]

Ed, we have a custom system with proprietary micro kernel and lots of applications/services running on top of it.
The entry point in our executables is always the beginning of RX segment - there is no _start symbol. There are lot
of build scripts for various components and setting "-Wl,-e,0" everywhere is not very convenient solution. That said,
I'm not doing this just for fun )

[evgeny777]

ELF/Driver.cpp

577–578

Unfortunately, I can't. The main problem is that in general _start symbol should exist in symtab, before adding files, otherwise LTO can optimize out everything.

[emaste]

Ed, we have a custom system with proprietary micro kernel and lots of applications/services running on top of it.
The entry point in our executables is always the beginning of RX segment - there is no _start symbol. There are lot
of build scripts for various components and setting "-Wl,-e,0" everywhere is not very convenient solution. That said,
I'm not doing this just for fun )

I didn't think you were doing it for fun and I had no opposition to the change, I was just curious how such an ELF file would be useful since I assumed all users would make use of __start / the entry point. So, sounds good to me.

[• rafael]

ELF/Driver.cpp

577–578

We don't check IsUsedInRegularObj for LTO until every file is read, so what causes it to decide that everything can be gced?

[• rafael]

Moving

if (!Config->Entry.empty()) {

down past

for (std::unique_ptr<InputFile> &F : Files)

only seems to change the order of symbols in the output and should allow you to check if there is a _start in the symbol table already.

BTW, if the input is just

.quad _start

we should still produce an error and I think this patch would not.

Also, looks like bfd default to some other value

d.bfd: warning: cannot find entry symbol _start; defaulting to 0000000000400040

[evgeny777]

down past
for (std::unique_ptr<InputFile> &F : Files)

As far as I understand, in case of bitcode files, symbols will be added to symtab in a call to addCombinedLtoObject(), which is called after LTO passes, right?
Will check all other issues.

[evgeny777]

Diff updated. Here I'm not adding entry symbol to symtab unless explicitly told. Two extra things done:

• If entry symbol is being inserted then IsUsedInRegularObj is always set to true to avoid incorrect LTO optimizations
• Extra checks are needed in addLazyArchive and addLazyObject to always create object file if it contains start symbol

The position of _start symbol in symbol table is arbitrary now, that's why some test cases were modified.

[ruiu]

Doesn't something like this (https://reviews.llvm.org/D24282) work? I think this is what Rafael and I were suggesting.

[evgeny777]

Great hint, thanks! Diff updated.

[ruiu]

LGTM

ELF/Config.h

struct Configuration {
   bool ZRelro;
   DiscardPolicy Discard;
   StripPolicy Strip = StripPolicy::None;
   UnresolvedPolicy UnresolvedSymbols;
   BuildIdKind BuildId = BuildIdKind::None;
   ELFKind EKind = ELFNoneKind;
   uint16_t DefaultSymbolVersion = llvm::ELF::VER_NDX_GLOBAL;
   uint16_t EMachine = llvm::ELF::EM_NONE;
-  uint64_t EntryAddr = -1;
+  uint64_t EntryAddr = 0;
   uint64_t ImageBase;
   uint64_t ZStackSize = -1;
   unsigned LtoJobs;
   unsigned LtoO;
   unsigned Optimize;
 };
 
 // The only instance of Configuration struct.
 extern Configuration *Config;
 
 } // namespace elf
 } // namespace lld
 
 #endif

ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   std::unique_ptr<TargetInfo> TI(createTarget());
   Target = TI.get();
   LinkerScript<ELFT> LS;
   Script<ELFT>::X = &LS;
 
   Config->Rela = ELFT::Is64Bits || Config->EMachine == EM_X86_64;
   Config->Mips64EL =
       (Config->EMachine == EM_MIPS && Config->EKind == ELF64LEKind);
 
-  // Add entry symbol. Note that AMDGPU binaries have no entry points.
-  if (Config->Entry.empty() && !Config->Shared && !Config->Relocatable &&
-      Config->EMachine != EM_AMDGPU)
-    Config->Entry = (Config->EMachine == EM_MIPS) ? "__start" : "_start";
-
   // Default output filename is "a.out" by the Unix tradition.
   if (Config->OutputFile.empty())
     Config->OutputFile = "a.out";
 
   // Handle --trace-symbol.
   for (auto *Arg : Args.filtered(OPT_trace_symbol))
     Symtab.trace(Arg->getValue());
 
-  // Set either EntryAddr (if S is a number) or EntrySym (otherwise).
-  if (!Config->Entry.empty()) {
-    StringRef S = Config->Entry;
-    if (S.getAsInteger(0, Config->EntryAddr))
-      Config->EntrySym = Symtab.addUndefined(S);
-  }
-
   // Initialize Config->ImageBase.
   if (auto *Arg = Args.getLastArg(OPT_image_base)) {
     StringRef S = Arg->getValue();
     if (S.getAsInteger(0, Config->ImageBase))
       error(Arg->getSpelling() + ": number expected, but got " + S);
     else if ((Config->ImageBase % Target->PageSize) != 0)
       warning(Arg->getSpelling() + ": address isn't multiple of page size");
   } else {
     Config->ImageBase = Config->Pic ? 0 : Target->DefaultImageBase;
   }
 
+  // Add all files to the symbol table. After this, the symbol table
+  // contains all known names except a few linker-synthesized symbols.
   for (std::unique_ptr<InputFile> &F : Files)
     Symtab.addFile(std::move(F));
+
+  // Add the start symbol.
+  // It initializes either Config->Entry or Config->EntryAddr.
+  // Note that AMDGPU binaries have no entries.
+  if (!Config->Entry.empty()) {
+    // It is either "-e <addr>" or "-e <symbol>".
+    if (Config->Entry.getAsInteger(0, Config->EntryAddr))
+      Config->EntrySym = Symtab.addUndefined(Config->Entry);
+  } else if (!Config->Shared && !Config->Relocatable &&
+             Config->EMachine != EM_AMDGPU) {
+    // -e was not specified. Use the default start symbol name
+    // if it is resolvable.
+    Config->Entry = (Config->EMachine == EM_MIPS) ? "__start" : "_start";
+    if (Symtab.find(Config->Entry))
+      Config->EntrySym = Symtab.addUndefined(Config->Entry);
+  }
+
   if (HasError)
     return; // There were duplicate symbols or incompatible files
 
   Symtab.scanUndefinedFlags();
   Symtab.scanShlibUndefined();
   Symtab.scanDynamicList();
   Symtab.scanVersionScript();
 

ELF/Writer.cpp

if (H.p_type == PT_TLS) {
         H.p_memsz = alignTo(H.p_memsz, H.p_align);
     }
   }
 }
 
 template <class ELFT> static typename ELFT::uint getEntryAddr() {
   if (Symbol *S = Config->EntrySym)
     return S->body()->getVA<ELFT>();
-  if (Config->EntryAddr != uint64_t(-1))
-    return Config->EntryAddr;
-  return 0;
 }
 
 template <class ELFT> static uint8_t getELFEncoding() {
   if (ELFT::TargetEndianness == llvm::support::little)
     return ELFDATA2LSB;
   return ELFDATA2MSB;
 }
 

test/ELF/arm-gnu-ifunc.s

 // CHECK-NEXT:    Binding: Local
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other [
 // CHECK-NEXT:      STV_HIDDEN
 // CHECK-NEXT:    ]
 // CHECK-NEXT:    Section: .rel.plt
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Symbol {
-// CHECK-NEXT:    Name: _start (6)
+// CHECK-NEXT:    Name: _start (38)
 // CHECK-NEXT:    Value: 0x11008
 // CHECK-NEXT:    Size: 0
 // CHECK-NEXT:    Binding: Global
 // CHECK-NEXT:    Type: None
 // CHECK-NEXT:    Other:
 // CHECK-NEXT:    Section: .text
 // CHECK-NEXT:  }
 // CHECK-NEXT:  Symbol {

test/ELF/edata-etext.s

 # CHECK-NEXT:    Value: 0x0
 # CHECK-NEXT:    Size: 0
 # CHECK-NEXT:    Binding: Local
 # CHECK-NEXT:    Type: None
 # CHECK-NEXT:    Other: 0
 # CHECK-NEXT:    Section: Undefined
 # CHECK-NEXT:  }
 # CHECK-NEXT:  Symbol {
-# CHECK-NEXT:    Name: _start
-# CHECK-NEXT:    Value: 0x11000
-# CHECK-NEXT:    Size: 0
-# CHECK-NEXT:    Binding: Global
-# CHECK-NEXT:    Type: None
-# CHECK-NEXT:    Other: 0
-# CHECK-NEXT:    Section: .text
-# CHECK-NEXT:  }
-# CHECK-NEXT:  Symbol {
 # CHECK-NEXT:    Name: _edata
 # CHECK-NEXT:    Value: 0x12002
 # CHECK-NEXT:    Size: 0
 # CHECK-NEXT:    Binding: Global
 # CHECK-NEXT:    Type: None
 # CHECK-NEXT:    Other: 0
 # CHECK-NEXT:    Section: Absolute
 # CHECK-NEXT:  }

 # CHECK-NEXT:    Name: _etext
 # CHECK-NEXT:    Value: 0x11001
 # CHECK-NEXT:    Size: 0
 # CHECK-NEXT:    Binding: Global
 # CHECK-NEXT:    Type: None
 # CHECK-NEXT:    Other: 0
 # CHECK-NEXT:    Section: Absolute
 # CHECK-NEXT:  }
+# CHECK-NEXT:  Symbol {
+# CHECK-NEXT:    Name: _start (20)
+# CHECK-NEXT:    Value: 0x11000
+# CHECK-NEXT:    Size: 0
+# CHECK-NEXT:    Binding: Global (0x1)
+# CHECK-NEXT:    Type: None (0x0)
+# CHECK-NEXT:    Other: 0
+# CHECK-NEXT:    Section: .text (0x1)
+# CHECK-NEXT:  }
 # CHECK-NEXT: ]
 
 .global _start,_end,_etext,_edata
 .text
 _start:
   nop
 .data
   .word 1
 .bss
   .align 4
   .space 6

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
+# RUN: llvm-readobj -file-headers %t2 | FileCheck -check-prefix=NOENTRY %s
 # RUN: ld.lld %t1 -o %t2 -e entry
 # RUN: llvm-readobj -file-headers %t2 | FileCheck -check-prefix=SYM %s
 # RUN: ld.lld %t1 -shared -o %t2 -e entry
 # RUN: llvm-readobj -file-headers %t2 | FileCheck -check-prefix=DSO %s
 # RUN: ld.lld %t1 -o %t2 --entry=4096
 # RUN: llvm-readobj -file-headers %t2 | FileCheck -check-prefix=DEC %s
 # RUN: ld.lld %t1 -o %t2 --entry 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
 
+# NOENTRY: Entry: 0x0
 # SYM: Entry: 0x11000
 # DSO: Entry: 0x1000
 # DEC: Entry: 0x1000
 # HEX: Entry: 0xCAFE
 # OCT: Entry: 0x1FF
 
 .globl entry
 entry:

test/ELF/linkerscript/symbols-synthetic.s

 # RUN:             *(.eh_frame_hdr) \
 # RUN:             *(.eh_frame_hdr) \
 # RUN:             PROVIDE_HIDDEN(_end_sec_abs = ABSOLUTE(.)); \
 # RUN:             PROVIDE_HIDDEN(_end_sec = .); } \
 # RUN:         }" > %t.script
 # RUN: ld.lld -o %t1 --eh-frame-hdr --script %t.script %t
 
 # SIMPLE:      0000000000000160         .foo    00000000 .hidden _end_sec
-# SIMPLE:      0000000000000158         .foo    00000000 _begin_sec
+# SIMPLE-NEXT: 0000000000000158         .foo    00000000 _begin_sec
 # SIMPLE-NEXT: 0000000000000160         *ABS*   00000000 _end_sec_abs
+# SIMPLE-NEXT: 0000000000001048         .text   00000000 _start
 # SIMPLE-NEXT: 0000000000000158         .foo    00000000 begin_foo
 # SIMPLE-NEXT: 0000000000000160         .foo    00000000 end_foo
 # SIMPLE-NEXT: 0000000000000008         .foo    00000000 size_foo_1
 # SIMPLE-NEXT: 0000000000000008         *ABS*   00000000 size_foo_1_abs
 # SIMPLE-NEXT: 0000000000001000         .foo    00000000 begin_bar
 # SIMPLE-NEXT: 0000000000001004         .foo    00000000 end_bar
 # SIMPLE-NEXT: 0000000000000eac         .foo    00000000 size_foo_2
 # SIMPLE-NEXT: 0000000000000eac         *ABS*   00000000 size_foo_3

test/ELF/reproduce-windows.s

 # REQUIRES: x86, cpio
 
 # Test that a repro archive always uses / instead of \.
 # RUN: rm -rf %t.dir
 # RUN: mkdir -p %t.dir/build
 # RUN: llvm-mc %s -o %t.dir/build/foo.o -filetype=obj -triple=x86_64-pc-linux
 # RUN: cd %t.dir
-# RUN: not ld.lld build/foo.o --reproduce repro
+# RUN: ld.lld build/foo.o --reproduce repro
 # RUN: cpio -t < repro.cpio | FileCheck %s
 
 # CHECK: repro/response.txt
 # CHECK: repro/{{.*}}/build/foo.o

test/ELF/resolution.s

 // CHECK-NEXT:     Value: 0x0
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Local (0x0)
 // CHECK-NEXT:     Type: None (0x0)
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: Undefined (0x0)
 // CHECK-NEXT:   }
 // CHECK-NEXT:   Symbol {
-// CHECK-NEXT:     Name: _start
-// CHECK-NEXT:     Value:
-// CHECK-NEXT:     Size: 0
-// CHECK-NEXT:     Binding: Global
-// CHECK-NEXT:     Type: None
-// CHECK-NEXT:     Other: 0
-// CHECK-NEXT:     Section: .text
-// CHECK-NEXT:   }
-// CHECK-NEXT:   Symbol {
 // CHECK-NEXT:     Name: CommonStrong_with_CommonStrong
 // CHECK-NEXT:     Value:
 // CHECK-NEXT:     Size: 63
 // CHECK-NEXT:     Binding: Global
 // CHECK-NEXT:     Type: Object
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section:
 // CHECK-NEXT:   }

 // CHECK-NEXT:     Name: UndefWeak_with_UndefWeak
 // CHECK-NEXT:     Value: 0x0
 // CHECK-NEXT:     Size: 0
 // CHECK-NEXT:     Binding: Weak
 // CHECK-NEXT:     Type: None
 // CHECK-NEXT:     Other: 0
 // CHECK-NEXT:     Section: Undefined
 // CHECK-NEXT:   }
+// CHECK-NEXT:  Symbol {
+// CHECK-NEXT:    Name: _start (929)
+// CHECK-NEXT:    Value: 0x11000
+// CHECK-NEXT:    Size: 0
+// CHECK-NEXT:    Binding: Global (0x1)
+// CHECK-NEXT:    Type: None (0x0)
+// CHECK-NEXT:    Other: 0
+// CHECK-NEXT:    Section: .text (0x1)
+// CHECK-NEXT:  }
 // CHECK-NEXT: ]
 
 .globl _start
 _start:
         nop
 
 local:
 

test/ELF/undef-start.s

 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
-# RUN: not ld.lld %t -o %t2 2>&1 | FileCheck %s
-# CHECK: undefined symbol: _start
+# RUN: ld.lld %t -o %t2 2>&1
 # REQUIRES: x86