[ELF2] Handle -m option

[denis-protivensky]

Summary

Parse and apply emulation given with -m option.
Check input files to match ELF type and machine architecture provided with -m.

Add positive tests for supported emulations.
Add negative test with unknown emulation.
Rework tests with incompatible emulation and input files.

[• rafael]

-m should not be mandatory, so you should not need to update every test.

[emaste]

ELF/Config.h

46

Do we have a way to get the host architecture type already?

ELF/Driver.cpp

49–52

Can we pick a sorting order so that as this list grows it stays consistent?

[denis-protivensky]

I did this so if the host is not x86-64 machine all the tests still pass.

[denis-protivensky]

ELF/Config.h

46

I'll rework this part so initial architecture doesn't matter that much. Will pick ELF & machine types from the first input file.

ELF/Driver.cpp

49–52

Will sort by emulation name.

[denis-protivensky]

Updated:

• Determine target from the first input file if no emulation given
• Sort emulations alphabetically in the array
• Revert adding -m option to all test cases, add only where needed

[denis-protivensky]

Updated once again:

• Rename OPT_m -> OPT_emulation
• Fix word spelling in error message

[emaste]

ELF/Config.h

47

Do we still need an EM_X86_64 default?

test/elf2/emulation.s

2

It would be nice to have some non-Linux triples as well (e.g. x86_64-unknown-freebsd). @davide or I could add some in a subsequent commit.

[• rafael]

ELF/Config.h

33

git-clang-format the patch.

Function names start with a lowercase letter.

ELF/Driver.cpp

92

Variable names start with an upper case letter.

100

This fails to build:

Driver.cpp:96:12: error: no viable conversion from returned value of type 'unique_ptr<lld::elf2::ELFFileBase>' to function return type 'unique_ptr<lld::elf2::InputFile>'

test/elf2/incompatible.s

8

That is a regression. When two things are incompatible we should still say what they are. An object file can be incompatible with another or with a -m option.

[denis-protivensky]

ELF/Config.h

47

It'll be replaced with a reasonable value during linking. Do you have ideas what to put here? EM_NONE?

test/elf2/emulation.s

2

Thanks.

[denis-protivensky]

Updated:

• Fix style
• Fix clang build error
• Provide source of target incompatibility

[• rafael]

ELF/Config.h

14

You only need Support/ELF.h

15

Not used

46

Can these two variables be left uninitialized? If not, please make them an explicit Optional<>. We really should not give EM_X86_64 or ELF64LE any special treatment.

ELF/SymbolTable.cpp

25–26

git-clang-format

[• rafael]

ELF/Driver.cpp

18

Unnecessary.

40

Replace this with a

using namespace llvm::ELF;

just after the existing

using namespace llvm;

84

Drop the inline.

[• rafael]

You can avoid creating the low level getElfMachineType by opening the
elf files earlier (see the attached patch).

• t.diff1 KBDownload

[ruiu]

ELF/Driver.cpp

44

ElfKind -> ELFKind

71

Passing an in-memory object as a StringRef feels a bit strange. Maybe you want to passs MemoryBuffer instead.

76–77

Remove this

77–78

Let's keep the original function name.

77–78

and this blank lines.

80–81

No need for else because the other path ends with return.

81

Move the definition of Emulations inside here as a static local constant because only this function uses that.

85–86

This function is probably too short to be defined as a function. Just write two lines of code where you call this function.

100

I'd remove this TargetDefined variable. Instead, I'd change the type of Config->ELFKind to Optional<>, and check for the existence of the value instead of a separate flag.

107

Looks like TargetSource is used just for printing this error message. Can you remove that? I think a detailed error message is generally good, but this error message is used rarely, and probably that wouldn't match the cost of having another variable here. Then we can keep createELFFile to take only one argument just like before.

[denis-protivensky]

@rafael, thanks for the patch, but I'd prefer to leave the getElfMachineType method since it allows to simplify the interface of ELFData class and ObjectFile/SharedFile. It removes bunch of methods from the .cpp file as well.

ELF/Config.h

14

Agreed.

15

I introduced the variable of uint16_t type, so this header is used and the style guide doesn't prohibit adding headers to avoid hidden dependencies.

46

Will make ElfKind optional and set EMachine to EM_NONE.

ELF/Driver.cpp

18

I'll change this to ELFTypes.h because it contains Elf_Ehdr_Impl definition.

44

This causes build errors with gcc, that's why I made it like that.

71

Will try.

77–78

Ok.

80–81

Ok.

81

Good point.

84

Is this something style-guide related or error-prone? Why to drop it?

85–86

I'm against the code duplication in general. Even for two-liner, so I'd like to leave it here.

100

Good.

107

That was my original design, but @rafael insisted we need this to avoid test regression. See comments for incompatible.s test below.

[denis-protivensky]

Maybe, but that is independent and pretty big, so it should be in another patch.

Agreed.

[ruiu]

ELF/Config.h

46

Or you could define a new enum, ELFNoneKind and use the value as an indicator of absence of a valid value.

ELF/Driver.cpp

84

The rule of thumb is we shouldn't write inline unless it's proved to be necessary. Basically this piece of code doesn't have to be optimized, or even the entire Driver doesn't have to be fast, because the runtime cost of Driver is negligible after all. I wouldn't even think about speed when writing the Driver to save my brain power to focus on something more important. :)

85–86

Well, that depends. If they are just one-line assignment statement to a Config member variable, you wouldn't make the "duplicate" assignments to a function. Two assignments are still more readable than a function call.

107

I feel like there must be some way to remove this parameter. Can we do this check not in this function but at Driver.cpp line 189?

[denis-protivensky]

ELF/Config.h

46

Better to have the optional, since defining one enum value used in only one case as a default looks like bad design.

ELF/Driver.cpp

71

MemoryBufferRef doesn't have suitable methods to operate on bytes, so I'll in any case need to construct StringRef from MemoryBufferRef inside. No profit in changing the signature, especially for non-public method.

107

Thought about that, but it would be worse: we'll have two logically equal checks of having ELFKind set in two different places. Moreover, we'll need to return nullptr value from the method and then check it in the loop. I don't feel it's worth doing.

[ruiu]

ELF/Config.h

46

No, it's not always bad, but sometimes good. Absence of a valid value is often represented using a null pointer, for example.

ELF/Driver.cpp

71

Why I felt that was a bit weird is because when I see a StringRef, I expect it would refer to some text string and not to arbitrary byte sequence (if that's the case, ArrayRef<uint8_t> would be suitable). So I'd think we should change the signature. You can call getBuffer() *inside* this function and not before calling this function.

[denis-protivensky]

Updated:

• Make ElfKind optional
• Move Emulations to the place of use
• Rename createTargetELFFile -> createELFFile
• Code style fixes
• Minimize the number of changes by excluding parts that may be removed

[ruiu]

ELF/Config.h

30

We name this function is64() in COFF.

ELF/Driver.cpp

85–86

I still think that inlining this function would be better.

90

Add a new member variable to Config for TargetSource and remove this from this parameter list. I'd name Config->FirstObjName.

102

*Config->ElfKind doesn't look beautiful. I'd add ELFNoneKind enum and use that to represent the absence of a valid value.

117–135

This looks more intricate than necessary. Plain if-then-else would be better.

if (Emul == "elf_i386") {
  ...
  return
}
if (Emul == ...) {
}
error("unknown emulation name: "...)

173

We don't have a comment for other options above.

[• rafael]

ELF/Driver.cpp

71

Drop this function. You can use the existing one.

[• rafael]

And please rebase the patch:

$ git apply -p0 ~/Downloads/D13055.diff
error: patch failed: ELF/Config.h:28
error: ELF/Config.h: patch does not apply
error: patch failed: ELF/Driver.cpp:47
error: ELF/Driver.cpp: patch does not apply
error: patch failed: ELF/Options.td:49
error: ELF/Options.td: patch does not apply

[denis-protivensky]

Updated:

• Rename is64Bits() -> is64()
• Add FirstObjFile config parameter
• Introduce ELFNoneKind
• Replace applyEmulation loop with if-else
• Remove configureTarget function
• Drop getElfMachineType function

[ruiu]

ELF/Driver.cpp

65–67

I think you can remove Twine() from this statement. Twine is to concatenate strings, so at least grouping an entire string with Twine() doesn't make sense.

[• rafael]

ELF/Config.h

30

git-clang-format

ELF/SymbolTable.cpp

26

git-clang-format

[• rafael]

You are missing a testcase where -m *is* compatible with the rest of
the elf files :-)

[• rafael]

Add a new member variable to Config for TargetSource and remove this from this parameter list. I'd name Config->FirstObjName.

The first object name is always available in the SymbolTable:

SymbolTable.getFirstELF()->getName()

Why do you need the extra variable?

[denis-protivensky]

In D13055#256840, @rafael wrote:

You are missing a testcase where -m *is* compatible with the rest of
the elf files :-)

I do have these tests in emulation.s file:

[denis-protivensky]

Sorry for the previous not full comment, just hit Submit button accidentally.

I do have these tests in emulation.s file:

# RUN: lld -flavor gnu2 -m elf64ppc %tppc64 -o %t2ppc64

[denis-protivensky]

Updated:

• Remove FirstOjbName Config variable, use Symtab.getFirstELF()->getName() instead
• clang-format sources

[• rafael]

This patch makes isCompatibleWith redundant and should remove it (See
attached patch).

I think this OK once rebased on top of trunk.
Rui, is this OK with you too?

• t.diff14 KBDownload

[denis-protivensky]

Updated:

• Remove isCompatibleWith method
• Rename OPT_emulation -> OPT_m
• Rename applyEmulation -> setELFType

Returned back FirstObjName config variable since we need a flag indicating whether ELF parameters were grabbed from the first object file or from the -m option.

[• rafael]

Returned back FirstObjName config variable since we need a flag indicating whether ELF parameters were grabbed from the first object file or from the -m option.

Why?

You report an error as soon as an incompatibility is found. If
getFirstELF returns non null, you know either

• There was a -m and it is compatible with it
• There was no -m and you don't have to worry about it

In any case you only have to check if that file is compatible with the
current one.

Cheers,
Rafael

[• rafael]

See the attached patch for example.

• t.diff9 KBDownload

[• rafael]

Just one more nit:

in ELFFileBase::getEMachine() I think you have to keep the
llvm_unreachable outside of the switch to avoid a gcc warning.

LGTM with that.

[denis-protivensky]

Updated:

• Remove FirstObjName in favor of always reporting incompatibility with the first object file if available.

[denis-protivensky]

In D13055#259679, @rafael wrote:

Just one more nit:

in ELFFileBase::getEMachine() I think you have to keep the
llvm_unreachable outside of the switch to avoid a gcc warning.

LGTM with that.

It's clang issuing warning because of extending ELFKind enum with ELFNoneKind value, that's why I moved the check. gcc doesn't give warning in either cases.

[ruiu]

ELF/Driver.cpp

115

I'd avoid giving the same name even if they live in different namespaces. Name this createELFInputFile.

126

Flip this condition to return early.

127–129

Separate two conditions

if (ELFFileBase *F = Symtab.getFirstELF())
  error(MB.getBufferIdentifier() + " is not compatible with" + F->getName());
error(MB.getBufferIdentifier() + " is not compatible with target architecture");

128–129

Can you remove Twine()? The result type of the expression inside Twine() is std::string, and because std::string -> Twine implicit conversion is defined, I believe you don't need that.

[denis-protivensky]

Updated:

• Rename createELFFile -> createELFInputFile
• Rework error handling in createELFInputFile - use early return, split error messages

[ruiu]

LGTM

ELF/Config.h

 //===- Config.h -------------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_CONFIG_H
 #define LLD_ELF_CONFIG_H
 
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ELF.h"
 
 #include <vector>
 
 namespace lld {
 namespace elf2 {
 
+enum ELFKind {
+  ELFNoneKind,
+  ELF32LEKind,
+  ELF32BEKind,
+  ELF64LEKind,
+  ELF64BEKind
+};
+
 struct Configuration {
+  bool is64() const {
+    return ElfKind == ELF64BEKind || ElfKind == ELF64LEKind;
+  }
+
   llvm::StringRef DynamicLinker;
   llvm::StringRef Entry;
   llvm::StringRef OutputFile = "a.out";
   llvm::StringRef Sysroot;
   std::string RPath;
   std::vector<llvm::StringRef> InputSearchPaths;
   bool AllowMultipleDefinition = false;
   bool DiscardAll = false;
   bool DiscardLocals = false;
   bool DiscardNone = false;
   bool ExportDynamic = false;
   bool NoInhibitExec = false;
   bool Shared = false;
+  ELFKind ElfKind = ELFNoneKind;
+  uint16_t EMachine = llvm::ELF::EM_NONE;
+  llvm::StringRef FirstObjName;
 };
 
 extern Configuration *Config;
 
 } // namespace elf2
 } // namespace lld
 
 #endif

ELF/Driver.cpp

 #include "Driver.h"
 #include "Config.h"
 #include "Error.h"
 #include "InputFiles.h"
 #include "SymbolTable.h"
 #include "Writer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
 using namespace llvm;
 
 using namespace lld;
 using namespace lld::elf2;
 
 namespace lld {
 namespace elf2 {
 Configuration *Config;
 
 void link(ArrayRef<const char *> Args) {
   Configuration C;
   Config = &C;
   LinkerDriver().link(Args.slice(1));
 }
 
 }
 }
 
 // Opens a file. Path has to be resolved already.
 // Newly created memory buffers are owned by this driver.
 MemoryBufferRef LinkerDriver::openFile(StringRef Path) {
   ErrorOr<std::unique_ptr<MemoryBuffer>> MBOrErr = MemoryBuffer::getFile(Path);
   error(MBOrErr, Twine("cannot open ") + Path);
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   MemoryBufferRef MBRef = MB->getMemBufferRef();
   OwningMBs.push_back(std::move(MB)); // take ownership
   return MBRef;
 }
 
+template <template <class> class T>
+static std::unique_ptr<InputFile> createTargetELFFile(MemoryBufferRef MB) {
+  std::unique_ptr<ELFFileBase> File = createELFFile<T>(MB);
+  const ELFKind ElfKind = File->getELFKind();
+  const uint16_t EMachine = File->getEMachine();
+
+  // Grab target from the first input file if wasn't set by -m option.
+  if (Config->ElfKind == ELFNoneKind) {
+    Config->ElfKind = ElfKind;
+    Config->EMachine = EMachine;
+    Config->FirstObjName = MB.getBufferIdentifier();
+    return std::move(File);
+  }
+
+  if (ElfKind != Config->ElfKind || EMachine != Config->EMachine)
+    error(Twine(MB.getBufferIdentifier() + " is incompatible with " +
+                (Config->FirstObjName.empty() ? "target architecture"
+                                              : Config->FirstObjName)));
+  return std::move(File);
+}
+
 static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
   using namespace llvm::sys::fs;
   file_magic Magic = identify_magic(MB.getBuffer());
 
   if (Magic == file_magic::archive)
     return make_unique<ArchiveFile>(MB);
-
   if (Magic == file_magic::elf_shared_object)
-    return createELFFile<SharedFile>(MB);
-
-  return createELFFile<ObjectFile>(MB);
+    return createTargetELFFile<SharedFile>(MB);
+  return createTargetELFFile<ObjectFile>(MB);
 }
 
 // Makes a path by concatenating Dir and File.
 // If Dir starts with '=' the result will be preceded by Sysroot,
 // which can be set with --sysroot command line switch.
 static std::string buildSysrootedPath(StringRef Dir, StringRef File) {
   SmallString<128> Path;
   if (Dir.startswith("="))
     sys::path::append(Path, Config->Sysroot, Dir.substr(1), File);
   else
     sys::path::append(Path, Dir, File);
   return Path.str().str();
 }
 
 // Searches a given library from input search paths, which are filled
 // from -L command line switches. Returns a path to an existent library file.
 static std::string searchLibrary(StringRef Path) {
   std::vector<std::string> Names;
   if (Path[0] == ':') {
     Names.push_back(Path.drop_front().str());
   } else {
     Names.push_back((Twine("lib") + Path + ".so").str());
     Names.push_back((Twine("lib") + Path + ".a").str());
   }
   for (StringRef Dir : Config->InputSearchPaths) {
     for (const std::string &Name : Names) {
       std::string FullPath = buildSysrootedPath(Dir, Name);
       if (sys::fs::exists(FullPath))
         return FullPath;
     }
   }
   error(Twine("Unable to find library -l") + Path);
 }
 
+static void applyEmulation(StringRef Emul) {
+  using namespace ELF;
+
+  if (Emul == "elf_i386") {
+    Config->ElfKind = ELF32LEKind;
+    Config->EMachine = EM_386;
+    return;
+  }
+  if (Emul == "elf_x86_64") {
+    Config->ElfKind = ELF64LEKind;
+    Config->EMachine = EM_X86_64;
+    return;
+  }
+  if (Emul == "elf32ppc") {
+    Config->ElfKind = ELF32BEKind;
+    Config->EMachine = EM_PPC;
+    return;
+  }
+  if (Emul == "elf64ppc") {
+    Config->ElfKind = ELF64BEKind;
+    Config->EMachine = EM_PPC64;
+    return;
+  }
+  error(Twine("Unknown emulation: ") + Emul);
+}
+
 void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   // Parse command line options.
   opt::InputArgList Args = Parser.parse(ArgsArr);
 
   if (auto *Arg = Args.getLastArg(OPT_output))
     Config->OutputFile = Arg->getValue();
 
   if (auto *Arg = Args.getLastArg(OPT_dynamic_linker))
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   Config->AllowMultipleDefinition = Args.hasArg(OPT_allow_multiple_definition);
   Config->DiscardAll = Args.hasArg(OPT_discard_all);
   Config->DiscardLocals = Args.hasArg(OPT_discard_locals);
   Config->DiscardNone = Args.hasArg(OPT_discard_none);
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
   Config->NoInhibitExec = Args.hasArg(OPT_noinhibit_exec);
   Config->Shared = Args.hasArg(OPT_shared);
 
+  if (auto *Arg = Args.getLastArg(OPT_emulation))
+    applyEmulation(Arg->getValue());
+
   // Create a list of input files.
   std::vector<MemoryBufferRef> Inputs;
 
   for (auto *Arg : Args.filtered(OPT_l, OPT_INPUT)) {
     StringRef Path = Arg->getValue();
     if (Arg->getOption().getID() == OPT_l) {
       Inputs.push_back(openFile(searchLibrary(Path)));
       continue;
void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   // Parse all input files and put all symbols to the symbol table.
   // The symbol table will take care of name resolution.
   for (MemoryBufferRef MB : Inputs) {
     std::unique_ptr<InputFile> File = createFile(MB);
     Symtab.addFile(std::move(File));
   }
 
   // Write the result.
-  const ELFFileBase *FirstObj = Symtab.getFirstELF();
-  switch (FirstObj->getELFKind()) {
+  switch (Config->ElfKind) {
   case ELF32LEKind:
     writeResult<object::ELF32LE>(&Symtab);
     return;
   case ELF32BEKind:
     writeResult<object::ELF32BE>(&Symtab);
     return;
   case ELF64LEKind:
     writeResult<object::ELF64LE>(&Symtab);
     return;
   case ELF64BEKind:
     writeResult<object::ELF64BE>(&Symtab);
     return;
+  default:
+    llvm_unreachable("Invalid kind");
   }
 }

ELF/InputFiles.h

 //===- InputFiles.h ---------------------------------------------*- C++ -*-===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLD_ELF_INPUT_FILES_H
 #define LLD_ELF_INPUT_FILES_H
 
+#include "Config.h"
 #include "InputSection.h"
 #include "Error.h"
 #include "Symbols.h"
 
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/DenseSet.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/Object/Archive.h"

 protected:
   InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {}
   MemoryBufferRef MB;
 
 private:
   const Kind FileKind;
 };
 
-enum ELFKind { ELF32LEKind, ELF32BEKind, ELF64LEKind, ELF64BEKind };
-
 class ELFFileBase : public InputFile {
 public:
   ELFFileBase(Kind K, ELFKind EKind, MemoryBufferRef M)
       : InputFile(K, M), EKind(EKind) {}
   static bool classof(const InputFile *F) {
     Kind K = F->kind();
     return K == ObjectKind || K == SharedKind;
   }

ELF/InputFiles.cpp

uint16_t ELFFileBase::getEMachine() const {
   case ELF32BEKind:
     return ::getEMachine<ELF32BE>(*this);
   case ELF32LEKind:
     return ::getEMachine<ELF32LE>(*this);
   case ELF64BEKind:
     return ::getEMachine<ELF64BE>(*this);
   case ELF64LEKind:
     return ::getEMachine<ELF64LE>(*this);
-  }
+  default:
     llvm_unreachable("Invalid kind");
   }
+}
 
 bool ELFFileBase::isCompatibleWith(const ELFFileBase &Other) const {
   return getELFKind() == Other.getELFKind() &&
          getEMachine() == Other.getEMachine();
 }
 
 namespace {
 class ECRAII {

ELF/Options.td

 def sysroot : Joined<["--"], "sysroot=">,
      HelpText<"Set the system root">;
 
 def entry : Separate<["--", "-"], "entry">, MetaVarName<"<entry>">,
      HelpText<"Name of entry point symbol">;
 
 def alias_entry : Separate<["-"], "e">,
      Alias<entry>;
+
+def emulation : Separate<["-"], "m">,
+     HelpText<"Set target emulation">;

ELF/SymbolTable.cpp

 using namespace llvm::object;
 using namespace llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf2;
 
 SymbolTable::SymbolTable() {}
 
 bool SymbolTable::shouldUseRela() const {
-  ELFKind K = getFirstELF()->getELFKind();
-  return K == ELF64LEKind || K == ELF64BEKind;
+  return Config->is64();
 }
 
 void SymbolTable::addFile(std::unique_ptr<InputFile> File) {
   File->parse();
   InputFile *FileP = File.release();
   if (auto *AF = dyn_cast<ArchiveFile>(FileP)) {
     ArchiveFiles.emplace_back(AF);
     for (Lazy &Sym : AF->getLazySymbols())
template <class ELFT> void SymbolTable::init(uint16_t EMachine) {
   resolve<ELFT>(Got);
 }
 
 template <class ELFT> void SymbolTable::addELFFile(ELFFileBase *File) {
   if (const ELFFileBase *Old = getFirstELF()) {
     if (!Old->isCompatibleWith(*File))
       error(Twine(Old->getName() + " is incompatible with " + File->getName()));
   } else {
-    init<ELFT>(File->getEMachine());
+    init<ELFT>(Config->EMachine);
   }
 
   if (auto *O = dyn_cast<ObjectFileBase>(File)) {
     ObjectFiles.emplace_back(O);
     for (SymbolBody *Body : O->getSymbols())
       resolve<ELFT>(Body);
   }
 
case ELF32BEKind:
     addELFFile<ELF32BE>(File);
     break;
   case ELF64LEKind:
     addELFFile<ELF64LE>(File);
     break;
   case ELF64BEKind:
     addELFFile<ELF64BE>(File);
     break;
+  default:
+    llvm_unreachable("Invalid kind");
   }
 }
 
 template <class ELFT>
 void SymbolTable::dupError(const SymbolBody &Old, const SymbolBody &New) {
   typedef typename ELFFile<ELFT>::Elf_Sym Elf_Sym;
   typedef typename ELFFile<ELFT>::Elf_Sym_Range Elf_Sym_Range;
 

ELF/Writer.cpp

template <class ELFT> void Writer<ELFT>::writeHeader() {
   const SymbolTable &Symtab = SymTabSec.getSymTable();
   auto &FirstObj = cast<ObjectFile<ELFT>>(*Symtab.getFirstELF());
   EHdr->e_ident[EI_OSABI] = FirstObj.getOSABI();
 
   // FIXME: Generalize the segment construction similar to how we create
   // output sections.
 
   EHdr->e_type = Config->Shared ? ET_DYN : ET_EXEC;
-  EHdr->e_machine = FirstObj.getEMachine();
+  EHdr->e_machine = Config->EMachine;
   EHdr->e_version = EV_CURRENT;
   SymbolBody *Entry = Symtab.getEntrySym();
   EHdr->e_entry =
       Entry ? getSymVA(cast<ELFSymbolBody<ELFT>>(*Entry), BssSec) : 0;
   EHdr->e_phoff = ProgramHeaderOff;
   EHdr->e_shoff = SectionHeaderOff;
   EHdr->e_ehsize = sizeof(Elf_Ehdr);
   EHdr->e_phentsize = sizeof(Elf_Phdr);

test/elf2/basic.s

 # NO_O_VAL: missing arg value for "-o", expected 1 argument.
 
 # RUN: not lld -flavor gnu2 --foo 2>&1 | FileCheck --check-prefix=UNKNOWN %s
 # UNKNOWN: unknown argument: --foo
 
 # RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
 # RUN: not lld -flavor gnu2 %t %t -o %t2 2>&1 | FileCheck --check-prefix=DUP %s
 # DUP: duplicate symbol: _start in {{.*}} and {{.*}}
+
+# RUN: not lld -flavor gnu2 %t -o %t -m wrong_emul 2>&1 | FileCheck --check-prefix=UNKNOWN_EMUL %s
+# UNKNOWN_EMUL: Unknown emulation: wrong_emul

test/elf2/emulation.s

+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %tx64
+# RUN: lld -flavor gnu2 -m elf_x86_64 %tx64 -o %t2x64
+# RUN: llvm-readobj -file-headers %t2x64 | FileCheck --check-prefix=X86-64 %s
+# RUN: lld -flavor gnu2 %tx64 -o %t3x64
+# RUN: llvm-readobj -file-headers %t3x64 | FileCheck --check-prefix=X86-64 %s
+# X86-64:      ElfHeader {
+# X86-64-NEXT:   Ident {
+# X86-64-NEXT:     Magic: (7F 45 4C 46)
+# X86-64-NEXT:     Class: 64-bit (0x2)
+# X86-64-NEXT:     DataEncoding: LittleEndian (0x1)
+# X86-64-NEXT:     FileVersion: 1
+# X86-64-NEXT:     OS/ABI: SystemV (0x0)
+# X86-64-NEXT:     ABIVersion: 0
+# X86-64-NEXT:     Unused: (00 00 00 00 00 00 00)
+# X86-64-NEXT:   }
+# X86-64-NEXT:   Type: Executable (0x2)
+# X86-64-NEXT:   Machine: EM_X86_64 (0x3E)
+# X86-64-NEXT:   Version: 1
+# X86-64-NEXT:   Entry: 0x11000
+# X86-64-NEXT:   ProgramHeaderOffset: 0x40
+# X86-64-NEXT:   SectionHeaderOffset: 0x1060
+# X86-64-NEXT:   Flags [ (0x0)
+# X86-64-NEXT:   ]
+# X86-64-NEXT:   HeaderSize: 64
+# X86-64-NEXT:   ProgramHeaderEntrySize: 56
+# X86-64-NEXT:   ProgramHeaderCount: 1
+# X86-64-NEXT:   SectionHeaderEntrySize: 64
+# X86-64-NEXT:   SectionHeaderCount: 6
+# X86-64-NEXT:    StringTableSectionIndex: 5
+# X86-64-NEXT: }
+
+# RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %s -o %tx86
+# RUN: lld -flavor gnu2 -m elf_i386 %tx86 -o %t2x86
+# RUN: llvm-readobj -file-headers %t2x86 | FileCheck --check-prefix=X86 %s
+# RUN: lld -flavor gnu2 %tx86 -o %t3x86
+# RUN: llvm-readobj -file-headers %t3x86 | FileCheck --check-prefix=X86 %s
+# X86:      ElfHeader {
+# X86-NEXT:   Ident {
+# X86-NEXT:     Magic: (7F 45 4C 46)
+# X86-NEXT:     Class: 32-bit (0x1)
+# X86-NEXT:     DataEncoding: LittleEndian (0x1)
+# X86-NEXT:     FileVersion: 1
+# X86-NEXT:     OS/ABI: SystemV (0x0)
+# X86-NEXT:     ABIVersion: 0
+# X86-NEXT:     Unused: (00 00 00 00 00 00 00)
+# X86-NEXT:   }
+# X86-NEXT:   Type: Executable (0x2)
+# X86-NEXT:   Machine: EM_386 (0x3)
+# X86-NEXT:   Version: 1
+# X86-NEXT:   Entry: 0x11000
+# X86-NEXT:   ProgramHeaderOffset: 0x34
+# X86-NEXT:   SectionHeaderOffset: 0x104C
+# X86-NEXT:   Flags [ (0x0)
+# X86-NEXT:   ]
+# X86-NEXT:   HeaderSize: 52
+# X86-NEXT:   ProgramHeaderEntrySize: 32
+# X86-NEXT:   ProgramHeaderCount: 1
+# X86-NEXT:   SectionHeaderEntrySize: 40
+# X86-NEXT:   SectionHeaderCount: 6
+# X86-NEXT:    StringTableSectionIndex: 5
+# X86-NEXT: }
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc64-unknown-linux %s -o %tppc64
+# RUN: lld -flavor gnu2 -m elf64ppc %tppc64 -o %t2ppc64
+# RUN: llvm-readobj -file-headers %t2ppc64 | FileCheck --check-prefix=PPC64 %s
+# RUN: lld -flavor gnu2 %tppc64 -o %t3ppc64
+# RUN: llvm-readobj -file-headers %t3ppc64 | FileCheck --check-prefix=PPC64 %s
+# PPC64:      ElfHeader {
+# PPC64-NEXT:   Ident {
+# PPC64-NEXT:     Magic: (7F 45 4C 46)
+# PPC64-NEXT:     Class: 64-bit (0x2)
+# PPC64-NEXT:     DataEncoding: BigEndian (0x2)
+# PPC64-NEXT:     FileVersion: 1
+# PPC64-NEXT:     OS/ABI: SystemV (0x0)
+# PPC64-NEXT:     ABIVersion: 0
+# PPC64-NEXT:     Unused: (00 00 00 00 00 00 00)
+# PPC64-NEXT:   }
+# PPC64-NEXT:   Type: Executable (0x2)
+# PPC64-NEXT:   Machine: EM_PPC64 (0x15)
+# PPC64-NEXT:   Version: 1
+# PPC64-NEXT:   Entry: 0x11000
+# PPC64-NEXT:   ProgramHeaderOffset: 0x40
+# PPC64-NEXT:   SectionHeaderOffset: 0x1060
+# PPC64-NEXT:   Flags [ (0x0)
+# PPC64-NEXT:   ]
+# PPC64-NEXT:   HeaderSize: 64
+# PPC64-NEXT:   ProgramHeaderEntrySize: 56
+# PPC64-NEXT:   ProgramHeaderCount: 1
+# PPC64-NEXT:   SectionHeaderEntrySize: 64
+# PPC64-NEXT:   SectionHeaderCount: 6
+# PPC64-NEXT:    StringTableSectionIndex: 5
+# PPC64-NEXT: }
+
+# RUN: llvm-mc -filetype=obj -triple=powerpc-unknown-linux %s -o %tppc
+# RUN: lld -flavor gnu2 -m elf32ppc %tppc -o %t2ppc
+# RUN: llvm-readobj -file-headers %t2ppc | FileCheck --check-prefix=PPC %s
+# RUN: lld -flavor gnu2 %tppc -o %t3ppc
+# RUN: llvm-readobj -file-headers %t3ppc | FileCheck --check-prefix=PPC %s
+# PPC:      ElfHeader {
+# PPC-NEXT:   Ident {
+# PPC-NEXT:     Magic: (7F 45 4C 46)
+# PPC-NEXT:     Class: 32-bit (0x1)
+# PPC-NEXT:     DataEncoding: BigEndian (0x2)
+# PPC-NEXT:     FileVersion: 1
+# PPC-NEXT:     OS/ABI: SystemV (0x0)
+# PPC-NEXT:     ABIVersion: 0
+# PPC-NEXT:     Unused: (00 00 00 00 00 00 00)
+# PPC-NEXT:   }
+# PPC-NEXT:   Type: Executable (0x2)
+# PPC-NEXT:   Machine: EM_PPC (0x14)
+# PPC-NEXT:   Version: 1
+# PPC-NEXT:   Entry: 0x11000
+# PPC-NEXT:   ProgramHeaderOffset: 0x34
+# PPC-NEXT:   SectionHeaderOffset: 0x104C
+# PPC-NEXT:   Flags [ (0x0)
+# PPC-NEXT:   ]
+# PPC-NEXT:   HeaderSize: 52
+# PPC-NEXT:   ProgramHeaderEntrySize: 32
+# PPC-NEXT:   ProgramHeaderCount: 1
+# PPC-NEXT:   SectionHeaderEntrySize: 40
+# PPC-NEXT:   SectionHeaderCount: 6
+# PPC-NEXT:    StringTableSectionIndex: 5
+# PPC-NEXT: }
+
+# REQUIRES: x86,ppc
+
+.globl _start;
+_start:

test/elf2/incompatible.s

 // RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %ta.o
 // RUN: llvm-mc -filetype=obj -triple=i686-unknown-linux %s -o %tb.o
 // RUN: lld -flavor gnu2 -shared %tb.o -o %ti686.so
 // RUN: llvm-mc -filetype=obj -triple=arm-unknown-linux %s -o %tc.o
 
 // RUN: not lld -flavor gnu2 %ta.o %tb.o -o %t 2>&1 | \
 // RUN:   FileCheck --check-prefix=A-AND-B %s
-// A-AND-B: a.o is incompatible with {{.*}}b.o
+// A-AND-B: b.o is incompatible with {{.*}}a.o
 
 // RUN: not lld -flavor gnu2 %tb.o %tc.o -o %t 2>&1 | \
 // RUN:   FileCheck --check-prefix=B-AND-C %s
-// B-AND-C: b.o is incompatible with {{.*}}c.o
+// B-AND-C: c.o is incompatible with {{.*}}b.o
 
 // RUN: not lld -flavor gnu2 %ta.o %ti686.so -o %t 2>&1 | \
 // RUN:   FileCheck --check-prefix=A-AND-SO %s
-// A-AND-SO: a.o is incompatible with {{.*}}i686.so
+// A-AND-SO: i686.so is incompatible with {{.*}}a.o
 
 // RUN: not lld -flavor gnu2 %tc.o %ti686.so -o %t 2>&1 | \
 // RUN:   FileCheck --check-prefix=C-AND-SO %s
-// C-AND-SO: c.o is incompatible with {{.*}}i686.so
+// C-AND-SO: i686.so is incompatible with {{.*}}c.o
 
 // RUN: not lld -flavor gnu2 %ti686.so %tc.o -o %t 2>&1 | \
 // RUN:   FileCheck --check-prefix=SO-AND-C %s
-// SO-AND-C: i686.so is incompatible with {{.*}}c.o
+// SO-AND-C: c.o is incompatible with {{.*}}i686.so
+
+// RUN: not lld -flavor gnu2 -m elf64ppc %ta.o -o %t 2>&1 | \
+// RUN:   FileCheck --check-prefix=A-ONLY %s
+// A-ONLY: a.o is incompatible with target architecture
+
+// RUN: not lld -flavor gnu2 -m elf64ppc %tb.o -o %t 2>&1 | \
+// RUN:   FileCheck --check-prefix=B-ONLY %s
+// B-ONLY: b.o is incompatible with target architecture
+
+// RUN: not lld -flavor gnu2 -m elf64ppc %tc.o -o %t 2>&1 | \
+// RUN:   FileCheck --check-prefix=C-ONLY %s
+// C-ONLY: c.o is incompatible with target architecture
+
+// RUN: not lld -flavor gnu2 -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 target architecture
+
+// RUN: not lld -flavor gnu2 -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 target architecture
 
 // REQUIRES: x86,arm