[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

552–557

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

552–557

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

552–557

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 Verbose;
   bool WarnCommon;
   bool ZCombreloc;
   bool ZExecStack;
   bool ZNodelete;
   bool ZNow;
   bool ZOrigin;
   bool ZRelro;
+  bool ForcedEntry = false;
   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 ImageBase;
   uint64_t ZStackSize = -1;

ELF/Driver.cpp

template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   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->EMachine != EM_AMDGPU) {
     Config->Entry = (Config->EMachine == EM_MIPS) ? "__start" : "_start";
+    Config->ForcedEntry = true;
+  }
 
   // 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());

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::finalizeSections() {
 
   // Now that we have defined all possible symbols including linker-
   // synthesized ones. Visit all symbols to give the finishing touches.
   for (Symbol *S : Symtab<ELFT>::X->getSymbols()) {
     SymbolBody *Body = S->body();
 
     // We only report undefined symbols in regular objects. This means that we
     // will accept an undefined reference in bitcode if it can be optimized out.
-    if (S->IsUsedInRegularObj && Body->isUndefined() && !S->isWeak())
+    if (S->IsUsedInRegularObj && Body->isUndefined() && !S->isWeak()) {
+      if (S == Config->EntrySym && Config->ForcedEntry)
+        continue;
       reportUndefined<ELFT>(Body);
+    }
 
     if (!includeInSymtab<ELFT>(*Body))
       continue;
     if (Out<ELFT>::SymTab)
       Out<ELFT>::SymTab->addSymbol(Body);
 
     if (Out<ELFT>::DynSymTab && S->includeInDynsym()) {
       Out<ELFT>::DynSymTab->addSymbol(Body);

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/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/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