[ELF] - Allow emulation to be different from input objects target.

[grimar]

Summary

I found that when tried to link "arch/x86/realmode/rm" component of linux kernel,
LLD reports:

ld: arch/x86/realmode/rm/header.o is incompatible with elf_x86_64
...

All objects are i386, but invocation contains -m elf_x86_64 and we report a error.
That does not seem to be correct. Both gold and bfd allow to link that. Specification says:

-m emulation
              Emulate  the  emulation  linker.   You can list the
              available emulations with the --verbose or  -V  op-
              tions.   This  option overrides the compiled-in de-
              fault, which is the system for which you configured
              ld.

Patch makes target to be created basing on machine type inferred from
first object. If that is not possible then emulation option is used.

This is PR31678

[grimar]

• Removed dead code.

[ruiu]

If I understand correctly, you are trying to do this thing in this patch: set alternative values to page size, max page size and image base if -m is specified. Is this correct?

If so, I think this patch does that in a convoluted way.

[grimar]

In D28898#650644, @ruiu wrote:

If I understand correctly, you are trying to do this thing in this patch: set alternative values to page size, max page size and image base if -m is specified. Is this correct?

Main aim of that patch was to allow combination of -m elf_x86_64 and i386 objects.
Previously LLD took machine type and other data from -m and ignored inferring from objects and reported a error finally.
Patch changes logic to check objects first. And only after that check -m if not inferred data.

Setting alternative values is secondary thing here. Though it is looks consistent with what bfd do
(https://llvm.org/bugs/show_bug.cgi?id=31678) and documentation in general I think.

[grimar]

• Simplified. Changed behavior to just override the emulation with parameters taken from object.

(test/ELF/mips-n32-emul.s is removed)

[ruiu]

I don't think this patch works if all object files are in static archives.

[grimar]

In D28898#651577, @ruiu wrote:

I don't think this patch works if all object files are in static archives.

Original code also does not work when all files in static archives, no ? It requires -m or at least one .o file.

[ruiu]

In D28898#651623, @grimar wrote:

In D28898#651577, @ruiu wrote:

I don't think this patch works if all object files are in static archives.

Original code also does not work when all files in static archives, no ? It requires -m or at least one .o file.

I think you actually changed the behavior. Now it needs at least one .o even if -m is given.

ELF/Driver.cpp

700–701

I think you could just remove this piece of code from inferMachineTypes to do the same thing, no?

[grimar]

• Added testcase.

[grimar]

In D28898#651627, @ruiu wrote:

In D28898#651623, @grimar wrote:

In D28898#651577, @ruiu wrote:

I don't think this patch works if all object files are in static archives.

Original code also does not work when all files in static archives, no ? It requires -m or at least one .o file.

I think you actually changed the behavior. Now it needs at least one .o even if -m is given.

No, it does not need. I added a testcase for demonstration.

ELF/Driver.cpp

700–701

Since current logic is "assign parameters from -m and right after that override them with values from objects", I think it is better to localize this logic in a single place.

Its even may be worth some refactoring. I believe it is possible to get rid of that overriding. What we could to is check that -m is one of supported early. Then logic could be in different, correct order: first try to set machine type from files and then, if not successed - set it from -m. I had to use overriding only because we still want (I think) to check -m values even if it is ignored.

[ruiu]

Are you sure that this is the right thing to do? It seems alarming -- it doesn't feel right to me to handle the -m option like that. It doesn't make sense, and I cannot justify why it should be like that. Can you give me an explanation why this is correct?

[ruiu]

I found that arch/x86/realmode/rm/realmode.lds.S has an OUTPUT_FORMAT directive, which is ignored by LLD at the moment. Isn't this the cause of the problem?

[grimar]

In D28898#652502, @ruiu wrote:

I found that arch/x86/realmode/rm/realmode.lds.S has an OUTPUT_FORMAT directive, which is ignored by LLD at the moment. Isn't this the cause of the problem?

I think it is not. GNU linkers are very inconsistent. Ignoring OUTPUT_FORMAT seems to be OK.
See my experiments results:

Lets say we have next 4 scripts and trying to link i386 objects with -m elf_x86_64 (just like PR31678):
1) First that has OUTPUT_FORMAT and OUTPUT_ARCH

OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
OUTPUT_ARCH(i386)
SECTIONS { ... }

Linker: result
BFD: YES
GOLD: YES, output is i386 in both cases.

2) Second has only OUTPUT_FORMAT:

OUTPUT_FORMAT("elf32-i386", "elf32-i386", "elf32-i386")
SECTIONS { ... }

BFD: YES and output is x86_64. That looks wierd result for i386 objects inputs, right ?
And if I add --emit-relocs, I see that it emits tons of NONE relocations instead of i386 ones:

Relocation section '.rel.text' at offset 0x2061b8 contains 131 entries:
  Offset          Info           Type           Sym. Value    Sym. Name
000000000000  000000000000 R_X86_64_NONE    
000000000000  000000000000 R_X86_64_NONE    
000000000000  000000000000 R_X86_64_NONE

So it looks output is some kind of 'forced'.

GOLD: YES and output is i386.

3) Third has only OUTPUT_ARCH:

OUTPUT_ARCH(i386)
SECTIONS { ... }

BFD: NO
ld.bfd: i386 architecture of input file `home/umb/linux_kernel/linux/linux/arch/x86/realmode/rm/header.o' is incompatible with i386:x86-64 output

GOLD: YES and output is i386.

4) Fourth has nothing:

SECTIONS { ... }

BFD: NO

ld.bfd: i386 architecture of input file `home/umb/linux_kernel/linux/linux/arch/x86/realmode/rm/header.o' is incompatible with i386:x86-64 output

GOLD: YES, output is i386

So looks gold takes output format from inputs and ignores OUTPUT_FORMAT/OUTPUT_ARCH, just like we do.
Taking machine format from inputs and overriding -m seems very simple logic that is easy to understand and solves initial problem,
it is consistent with gold.
In my opinion gold behavior is much simpler than what bfd tries to do and we can try to stick to it.

[grimar]

• Updated in according to discussion.

[grimar]

ELF/Driver.cpp

706

This should be "all our inputs are binaries, "
At this point all bitcode files are already handled in loop above:

for (InputFile *F : Files) {

I'll update this comment for next diff/commit.

[ruiu]

What this does is probably okay, but this patch seems to be juggling data around unnecessarily. You probably want to restart from scratch to get cleaner code.

[ruiu]

I wouldn't submit this. Even two GNU linkers behave differently, and the new behavior this patch implements has odd semantics which is unable to describe other than "because the gold linker does that." And the original code that we are trying to handle seems to be just a typo. All in all, the best thing we should do now seems to fix the Linux kernel. If this issue resurfaces, we'll consider this patch again.

[grimar]

Bug was posted for linux kernel instead: https://bugzilla.kernel.org/show_bug.cgi?id=194091

ELF/Driver.cpp

for (auto *Arg : Args.filtered(OPT_L))
     Config->SearchPaths.push_back(Arg->getValue());
 
   std::vector<StringRef> RPaths;
   for (auto *Arg : Args.filtered(OPT_rpath))
     RPaths.push_back(Arg->getValue());
   if (!RPaths.empty())
     Config->RPath = llvm::join(RPaths.begin(), RPaths.end(), ":");
 
-  if (auto *Arg = Args.getLastArg(OPT_m)) {
-    // Parse ELF{32,64}{LE,BE} and CPU type.
-    StringRef S = Arg->getValue();
-    std::tie(Config->EKind, Config->EMachine, Config->OSABI) =
-        parseEmulation(S);
-    Config->MipsN32Abi = (S == "elf32btsmipn32" || S == "elf32ltsmipn32");
-    Config->Emulation = S;
-  }
-
   Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition);
   Config->Bsymbolic = Args.hasArg(OPT_Bsymbolic);
   Config->BsymbolicFunctions = Args.hasArg(OPT_Bsymbolic_functions);
   Config->Demangle = getArg(Args, OPT_demangle, OPT_no_demangle, true);
   Config->DisableVerify = Args.hasArg(OPT_disable_verify);
   Config->EhFrameHdr = Args.hasArg(OPT_eh_frame_hdr);
   Config->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->ExportDynamic =
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
   Config->Shared = Args.hasArg(OPT_shared);
   Config->Target1Rel = getArg(Args, OPT_target1_rel, OPT_target1_abs, false);
   Config->Threads = getArg(Args, OPT_threads, OPT_no_threads, true);
   Config->Trace = Args.hasArg(OPT_trace);
   Config->Verbose = Args.hasArg(OPT_verbose);
   Config->WarnCommon = Args.hasArg(OPT_warn_common);
 
   Config->DynamicLinker = getString(Args, OPT_dynamic_linker);
+  Config->Emulation = getString(Args, OPT_m);
   Config->Entry = getString(Args, OPT_entry);
   Config->Fini = getString(Args, OPT_fini, "_fini");
   Config->Init = getString(Args, OPT_init, "_init");
   Config->LTOAAPipeline = getString(Args, OPT_lto_aa_pipeline);
   Config->LTONewPmPasses = getString(Args, OPT_lto_newpm_passes);
   Config->MapFile = getString(Args, OPT_Map);
   Config->OutputFile = getString(Args, OPT_o);
   Config->SoName = getString(Args, OPT_soname);
case OPT_end_lib:
       break;
     }
   }
 
   if (Files.empty() && ErrorCount == 0)
     error("no input files");
 }
 
-// If -m <machine_type> was not given, infer it from object files.
+// Try to infer machine type from objects. If it is not possible, take it from
+// -m command line option.
 void LinkerDriver::inferMachineType() {
   if (Config->EKind != ELFNoneKind)
     return;
 
   for (InputFile *F : Files) {
     if (F->EKind == ELFNoneKind)
       continue;
     Config->EKind = F->EKind;
     Config->EMachine = F->EMachine;
     Config->OSABI = F->OSABI;
     Config->MipsN32Abi = Config->EMachine == EM_MIPS && isMipsN32Abi(F);
     return;
   }
+
+  if (Config->Emulation.empty())
     error("target emulation unknown: -m or at least one .o file required");
+
+  std::tie(Config->EKind, Config->EMachine, Config->OSABI) =
+      parseEmulation(Config->Emulation);
+  Config->MipsN32Abi = isMipsN32AbiEmulation(Config->Emulation);
 }
 
 // Parse -z max-page-size=<value>. The default value is defined by
 // each target.
 static uint64_t getMaxPageSize(opt::InputArgList &Args) {
   uint64_t Val =
       getZOptionValue(Args, "max-page-size", Target->DefaultMaxPageSize);
   if (!isPowerOf2_64(Val))
if (S.getAsInteger(0, V)) {
     error("-image-base: number expected, but got " + S);
     return 0;
   }
   if ((V % Config->MaxPageSize) != 0)
     warn("-image-base: address isn't multiple of page size: " + S);
   return V;
 }
 
+// Create target. If emulation option specified then replace
+// target's default parameters with emulated target parameters.
+static TargetInfo *createEmulation() {
+  TargetInfo *Target = createTarget(Config->EKind, Config->EMachine);
+  if (Config->Emulation.empty())
+    return Target;
+
+  ELFKind EmuKind;
+  uint16_t EmuMachine;
+  uint8_t EmuOSABI;
+  std::tie(EmuKind, EmuMachine, EmuOSABI) = parseEmulation(Config->Emulation);
+
+  // OSABI is overriden when emulation is specified.
+  Config->OSABI = EmuOSABI;
+
+  TargetInfo *EmuTarget = createTarget(EmuKind, EmuMachine);
+  Target->PageSize = EmuTarget->PageSize;
+  Target->DefaultMaxPageSize = EmuTarget->DefaultMaxPageSize;
+  Target->DefaultImageBase = EmuTarget->DefaultImageBase;
+  return Target;
+}
+
 // Do actual linking. Note that when this function is called,
 // all linker scripts have already been parsed.
 template <class ELFT> void LinkerDriver::link(opt::InputArgList &Args) {
   SymbolTable<ELFT> Symtab;
   elf::Symtab<ELFT>::X = &Symtab;
-  Target = createTarget();
+  Target = createEmulation();
   ScriptBase = Script<ELFT>::X = make<LinkerScript<ELFT>>();
 
   Config->Rela =
       ELFT::Is64Bits || Config->EMachine == EM_X86_64 || Config->MipsN32Abi;
   Config->Mips64EL =
       (Config->EMachine == EM_MIPS && Config->EKind == ELF64LEKind);
   Config->MaxPageSize = getMaxPageSize(Args);
   Config->ImageBase = getImageBase(Args);

ELF/Mips.cpp

case ELF64LEKind:
     return isN32Abi<ELF64LE>(F);
   case ELF64BEKind:
     return isN32Abi<ELF64BE>(F);
   default:
     llvm_unreachable("unknown Config->EKind");
   }
 }
 
+bool elf::isMipsN32AbiEmulation(StringRef S) {
+  return S == "elf32btsmipn32" || S == "elf32ltsmipn32";
+}
+
 template uint32_t elf::getMipsEFlags<ELF32LE>();
 template uint32_t elf::getMipsEFlags<ELF32BE>();
 template uint32_t elf::getMipsEFlags<ELF64LE>();
 template uint32_t elf::getMipsEFlags<ELF64BE>();

ELF/SymbolTable.cpp

 // MIPS object files.) This function checks for that error.
 template <class ELFT> static bool isCompatible(InputFile *F) {
   if (!isa<ELFFileBase<ELFT>>(F) && !isa<BitcodeFile>(F))
     return true;
 
   if (F->EKind == Config->EKind && F->EMachine == Config->EMachine) {
     if (Config->EMachine != EM_MIPS)
       return true;
-    if (isMipsN32Abi(F) == Config->MipsN32Abi)
+
+    bool IsN32Abi = isMipsN32Abi(F);
+    if (!Config->Emulation.empty() &&
+        isMipsN32AbiEmulation(Config->Emulation) != IsN32Abi) {
+      error(toString(F) + " is incompatible with " + Config->Emulation);
+      return false;
+    }
+
+    if (IsN32Abi == Config->MipsN32Abi)
       return true;
   }
 
-  if (!Config->Emulation.empty())
-    error(toString(F) + " is incompatible with " + Config->Emulation);
-  else
-    error(toString(F) + " is incompatible with " + toString(Config->FirstElf));
   return false;
 }
 
 // Add symbols in File to the symbol table.
 template <class ELFT> void SymbolTable<ELFT>::addFile(InputFile *File) {
   if (!isCompatible<ELFT>(File))
     return;
 

ELF/Target.h

public:
   virtual void relaxTlsIeToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
   virtual void relaxTlsLdToLe(uint8_t *Loc, uint32_t Type, uint64_t Val) const;
 };
 
 uint64_t getPPC64TocBase();
 uint64_t getAArch64Page(uint64_t Expr);
 
 extern TargetInfo *Target;
-TargetInfo *createTarget();
+TargetInfo *createTarget(ELFKind Kind, uint16_t Machine);
 }
 
 std::string toString(uint32_t RelType);
 }
 
 #endif

ELF/Target.cpp

void writePlt(uint8_t *Buf, uint64_t GotEntryAddr, uint64_t PltEntryAddr,
                 int32_t Index, unsigned RelOff) const override;
   RelExpr getThunkExpr(RelExpr Expr, uint32_t RelocType, const InputFile *File,
                        const SymbolBody &S) const override;
   void relocateOne(uint8_t *Loc, uint32_t Type, uint64_t Val) const override;
   bool usesOnlyLowPageBits(uint32_t Type) const override;
 };
 } // anonymous namespace
 
-TargetInfo *createTarget() {
-  switch (Config->EMachine) {
+TargetInfo *createTarget(ELFKind Kind, uint16_t Machine) {
+  switch (Machine) {
   case EM_386:
   case EM_IAMCU:
     return make<X86TargetInfo>();
   case EM_AARCH64:
     return make<AArch64TargetInfo>();
   case EM_AMDGPU:
     return make<AMDGPUTargetInfo>();
   case EM_ARM:
     return make<ARMTargetInfo>();
   case EM_MIPS:
-    switch (Config->EKind) {
+    switch (Kind) {
     case ELF32LEKind:
       return make<MipsTargetInfo<ELF32LE>>();
     case ELF32BEKind:
       return make<MipsTargetInfo<ELF32BE>>();
     case ELF64LEKind:
       return make<MipsTargetInfo<ELF64LE>>();
     case ELF64BEKind:
       return make<MipsTargetInfo<ELF64BE>>();

ELF/Writer.h

 template <class ELFT> void reportDiscarded(InputSectionBase<ELFT> *IS);
 
 template <class ELFT> uint32_t getMipsEFlags();
 
 uint8_t getMipsFpAbiFlag(uint8_t OldFlag, uint8_t NewFlag,
                          llvm::StringRef FileName);
 
 bool isMipsN32Abi(const InputFile *F);
+bool isMipsN32AbiEmulation(llvm::StringRef S);
 }
 }
 
 #endif

test/ELF/driver.test

 # REQUIRES: x86
 
 # RUN: not ld.lld --unknown1 --unknown2 -m foo /no/such/file -lnosuchlib \
 # RUN:   2>&1 | FileCheck -check-prefix=UNKNOWN %s
 
 # UNKNOWN: unknown argument: --unknown1
 # UNKNOWN: unknown argument: --unknown2
-# UNKNOWN: unknown emulation: foo
 # UNKNOWN: cannot open /no/such/file
 # UNKNOWN: unable to find library -lnosuchlib
+# UNKNOWN: unknown emulation: foo
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not ld.lld %t -o /no/such/file 2>&1 | FileCheck -check-prefix=MISSING %s
 # MISSING: failed to open /no/such/file
 
 # RUN: ld.lld --help 2>&1 | FileCheck -check-prefix=HELP %s
 # HELP: USAGE:
 

test/ELF/emulation-override.s

+# REQUIRES: x86
+# RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %s -o %t.o
+
+## Show target output without emulation.
+# RUN: ld.lld %t.o -o %t1
+# RUN: llvm-readobj -program-headers %t1 | FileCheck %s
+# CHECK:      ProgramHeader {
+# CHECK:        Type: PT_LOAD
+# CHECK-NEXT:   Offset:
+# CHECK-NEXT:   VirtualAddress: 0x10000
+
+## Check that we are able to apply elf_x86_64 emulation for i386 object
+## and target parameters are emulated.
+# RUN: ld.lld -m elf_x86_64 %t.o -o %t2
+# RUN: llvm-readobj -program-headers %t2 | FileCheck %s --check-prefix=OVERRIDE
+# OVERRIDE:      ProgramHeader {
+# OVERRIDE:        Type: PT_LOAD
+# OVERRIDE-NEXT:   Offset:
+# OVERRIDE-NEXT:   VirtualAddress: 0x200000
+
+.globl _start
+_start:
+ nop
+

test/ELF/incompatible.s

 // RUN: not ld.lld %tc.o %ti686.so -o %t 2>&1 | \
 // RUN:   FileCheck --check-prefix=C-AND-SO %s
 // C-AND-SO: i686.so is incompatible with {{.*}}c.o
 
 // RUN: not ld.lld %ti686.so %tc.o -o %t 2>&1 | \
 // RUN:   FileCheck --check-prefix=SO-AND-C %s
 // SO-AND-C: c.o is incompatible with {{.*}}i686.so
 
-// RUN: not ld.lld -m elf64ppc %ta.o -o %t 2>&1 | \
-// RUN:   FileCheck --check-prefix=A-ONLY %s
-// A-ONLY: a.o is incompatible with elf64ppc
-
-// RUN: not ld.lld -m elf64ppc %tb.o -o %t 2>&1 | \
-// RUN:   FileCheck --check-prefix=B-ONLY %s
-// B-ONLY: b.o is incompatible with elf64ppc
-
-// RUN: not ld.lld -m elf64ppc %tc.o -o %t 2>&1 | \
-// RUN:   FileCheck --check-prefix=C-ONLY %s
-// C-ONLY: c.o is incompatible with elf64ppc
-
-// RUN: not ld.lld -m elf_i386 %tc.o %ti686.so -o %t 2>&1 | \
-// RUN:   FileCheck --check-prefix=C-AND-SO-I386 %s
-// C-AND-SO-I386: c.o is incompatible with elf_i386
-
-// RUN: not ld.lld -m elf_i386 %ti686.so %tc.o -o %t 2>&1 | \
-// RUN:   FileCheck --check-prefix=SO-AND-C-I386 %s
-// SO-AND-C-I386: c.o is incompatible with elf_i386
-
-
 // We used to fail to identify this incompatibility and crash trying to
 // read a 64 bit file as a 32 bit one.
 // RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %p/Inputs/archive2.s -o %ta.o
 // RUN: llvm-ar rc %t.a %ta.o
 // RUN: llvm-mc -filetype=obj -triple=i686-linux %s -o %tb.o
 // RUN: not ld.lld %t.a %tb.o 2>&1 | FileCheck --check-prefix=ARCHIVE %s
 // ARCHIVE: .a({{.*}}a.o) is incompatible with {{.*}}b.o
 .global _start
 _start:
 .data
         .long foo
 
 // REQUIRES: x86,aarch64