[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

39 ↗

(On Diff #35368)

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

ELF/Driver.cpp

49–52 ↗

(On Diff #35368)

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

39 ↗

(On Diff #35368)

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 ↗

(On Diff #35368)

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

39 ↗

(On Diff #35475)

Do we still need an EM_X86_64 default?

test/elf2/emulation.s

1 ↗

(On Diff #35475)

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

26 ↗

(On Diff #35475)

git-clang-format the patch.

Function names start with a lowercase letter.

ELF/Driver.cpp

88 ↗

(On Diff #35475)

Variable names start with an upper case letter.

96 ↗

(On Diff #35475)

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 ↗

(On Diff #35475)

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

39 ↗

(On Diff #35475)

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

test/elf2/emulation.s

1 ↗

(On Diff #35475)

Thanks.

[denis-protivensky]

Updated:

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

[• rafael]

ELF/Config.h

14 ↗

(On Diff #35501)

You only need Support/ELF.h

15 ↗

(On Diff #35501)

Not used

35 ↗

(On Diff #35501)

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 ↗

(On Diff #35501)

git-clang-format

[• rafael]

ELF/Driver.cpp

18 ↗

(On Diff #35501)

Unnecessary.

40 ↗

(On Diff #35501)

Replace this with a

using namespace llvm::ELF;

just after the existing

using namespace llvm;

80 ↗

(On Diff #35501)

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 ↗

(On Diff #35501)

ElfKind -> ELFKind

67 ↗

(On Diff #35501)

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

76–77 ↗

(On Diff #35501)

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

81–82 ↗

(On Diff #35501)

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

96 ↗

(On Diff #35501)

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.

103 ↗

(On Diff #35501)

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.

114 ↗

(On Diff #35501)

Remove this

116 ↗

(On Diff #35501)

Let's keep the original function name.

117 ↗

(On Diff #35501)

and this blank lines.

121 ↗

(On Diff #35501)

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

[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 ↗

(On Diff #35501)

Agreed.

15 ↗

(On Diff #35501)

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.

35 ↗

(On Diff #35501)

Will make ElfKind optional and set EMachine to EM_NONE.

ELF/Driver.cpp

18 ↗

(On Diff #35501)

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

44 ↗

(On Diff #35501)

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

67 ↗

(On Diff #35501)

Will try.

76–77 ↗

(On Diff #35501)

Ok.

80 ↗

(On Diff #35501)

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

81–82 ↗

(On Diff #35501)

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

96 ↗

(On Diff #35501)

Good.

103 ↗

(On Diff #35501)

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

116 ↗

(On Diff #35501)

Ok.

121 ↗

(On Diff #35501)

Good point.

[denis-protivensky]

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

Agreed.

[ruiu]

ELF/Config.h

35 ↗

(On Diff #35501)

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

ELF/Driver.cpp

80 ↗

(On Diff #35501)

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. :)

81–82 ↗

(On Diff #35501)

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.

103 ↗

(On Diff #35501)

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

35 ↗

(On Diff #35501)

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

67 ↗

(On Diff #35501)

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.

103 ↗

(On Diff #35501)

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

35 ↗

(On Diff #35501)

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

67 ↗

(On Diff #35501)

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

26 ↗

(On Diff #35862)

We name this function is64() in COFF.

ELF/Driver.cpp

65–66 ↗

(On Diff #35862)

I still think that inlining this function would be better.

70 ↗

(On Diff #35862)

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

82 ↗

(On Diff #35862)

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

125–143 ↗

(On Diff #35862)

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

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

187 ↗

(On Diff #35862)

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

[• rafael]

ELF/Driver.cpp

51 ↗

(On Diff #35862)

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 ↗

(On Diff #36088)

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 ↗

(On Diff #36088)

git-clang-format

ELF/SymbolTable.cpp

26 ↗

(On Diff #36088)

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

96 ↗

(On Diff #36512)

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

107 ↗

(On Diff #36512)

Flip this condition to return early.

108–110 ↗

(On Diff #36512)

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");

109–110 ↗

(On Diff #36512)

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

lld/trunk/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 {
   llvm::StringRef DynamicLinker;
   llvm::StringRef Entry;
   llvm::StringRef Fini = "_fini";
   llvm::StringRef Init = "_init";
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   std::string RPath;
   std::vector<llvm::StringRef> InputSearchPaths;
   bool AllowMultipleDefinition;
   bool DiscardAll;
   bool DiscardLocals;
   bool DiscardNone;
   bool EnableNewDtags;
   bool ExportDynamic;
   bool NoInhibitExec;
   bool NoUndefined;
   bool Shared;
   bool Static = false;
   bool WholeArchive = false;
+  ELFKind ElfKind = ELFNoneKind;
+  uint16_t EMachine = llvm::ELF::EM_NONE;
 };
 
 extern Configuration *Config;
 
 } // namespace elf2
 } // namespace lld
 
 #endif

lld/trunk/ELF/Driver.h

 };
 
 class LinkerDriver {
 public:
   void link(ArrayRef<const char *> Args);
   void addFile(StringRef Path);
 
 private:
+  template <template <class> class T>
+  std::unique_ptr<ELFFileBase> createELFInputFile(MemoryBufferRef MB);
+
   SymbolTable Symtab;
   ArgParser Parser;
   std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
 };
 
 // Create enum with OPT_xxx values for each option in Options.td
 enum {
   OPT_INVALID = 0,

lld/trunk/ELF/Driver.cpp

 #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 llvm::ELF;
 
 using namespace lld;
 using namespace lld::elf2;
 
 Configuration *lld::elf2::Config;
 LinkerDriver *lld::elf2::Driver;
 
 void lld::elf2::link(ArrayRef<const char *> Args) {
   Configuration C;
   LinkerDriver D;
   Config = &C;
   Driver = &D;
   Driver->link(Args.slice(1));
 }
 
+static void setELFType(StringRef Emul) {
+  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);
+}
+
 // 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
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);
 }
 
+template <template <class> class T>
+std::unique_ptr<ELFFileBase>
+LinkerDriver::createELFInputFile(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;
+    return File;
+  }
+  if (ElfKind == Config->ElfKind && EMachine == Config->EMachine)
+    return File;
+
+  if (const ELFFileBase *First = Symtab.getFirstELF())
+    error(MB.getBufferIdentifier() + " is incompatible with " +
+          First->getName());
+  error(MB.getBufferIdentifier() + " is incompatible with target architecture");
+}
+
 // Opens and parses a file. Path has to be resolved already.
 // Newly created memory buffers are owned by this driver.
 void LinkerDriver::addFile(StringRef Path) {
   using namespace llvm::sys::fs;
   auto 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 MB ownership
 
   switch (identify_magic(MBRef.getBuffer())) {
   case file_magic::unknown:
     readLinkerScript(MBRef);
     return;
   case file_magic::archive:
     Symtab.addFile(make_unique<ArchiveFile>(MBRef));
     return;
   case file_magic::elf_shared_object:
-    Symtab.addFile(createELFFile<SharedFile>(MBRef));
+    Symtab.addFile(createELFInputFile<SharedFile>(MBRef));
     return;
   default:
-    Symtab.addFile(createELFFile<ObjectFile>(MBRef));
+    Symtab.addFile(createELFInputFile<ObjectFile>(MBRef));
   }
 }
 
 void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   // Parse command line options.
   opt::InputArgList Args = Parser.parse(ArgsArr);
 
   if (auto *Arg = Args.getLastArg(OPT_output))
if (auto *Arg = Args.getLastArg(OPT_fini))
     Config->Fini = Arg->getValue();
 
   if (auto *Arg = Args.getLastArg(OPT_init))
     Config->Init = Arg->getValue();
 
   if (auto *Arg = Args.getLastArg(OPT_soname))
     Config->SoName = Arg->getValue();
 
+  if (auto *Arg = Args.getLastArg(OPT_m))
+    setELFType(Arg->getValue());
+
   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->EnableNewDtags = !Args.hasArg(OPT_disable_new_dtags);
   Config->ExportDynamic = Args.hasArg(OPT_export_dynamic);
   Config->NoInhibitExec = Args.hasArg(OPT_noinhibit_exec);
   Config->NoUndefined = Args.hasArg(OPT_no_undefined);
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");
   }
 }

lld/trunk/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;
   }
 
-  bool isCompatibleWith(const ELFFileBase &Other) const;
   ELFKind getELFKind() const { return EKind; }
 
   uint16_t getEMachine() const;
 
 protected:
   const ELFKind EKind;
 };
 

lld/trunk/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 {
   std::error_code EC;
 
 public:
   std::error_code &getEC() { return EC; }

lld/trunk/ELF/Options.td

def fini : Separate<["-"], "fini">, MetaVarName<"<symbol>">,
   HelpText<"Specify a finalizer function">;
 
 def init : Separate<["-"], "init">, MetaVarName<"<symbol>">,
   HelpText<"Specify an initializer function">;
 
 def l : Joined<["-"], "l">, MetaVarName<"<libName>">,
   HelpText<"Root name of library to use">;
 
+def m : Separate<["-"], "m">,
+  HelpText<"Set target emulation">;
+
 def no_allow_shlib_undefined : Flag<["--"], "no-allow-shlib-undefined">;
 
 def no_whole_archive : Flag<["--"], "no-whole-archive">,
   HelpText<"Restores the default behavior of loading archive members">;
 
 def noinhibit_exec : Flag<["--"], "noinhibit-exec">,
   HelpText<"Retain the executable output file whenever it is still usable">;
 

 // Options listed below are silently ignored now.
 def O3 : Flag<["-"], "O3">;
 def as_needed : Flag<["--"], "as-needed">;
 def build_id : Flag<["--"], "build-id">;
 def eh_frame_hdr : Flag<["--"], "eh-frame-hdr">;
 def end_group : Flag<["--"], "end-group">;
 def gc_sections : Flag<["--"], "gc-sections">;
 def hash_style : Joined<["--"], "hash-style=">;
-def m : Separate<["-"], "m">;
 def no_add_needed : Flag<["--"], "no-add-needed">;
 def no_as_needed : Flag<["--"], "no-as-needed">;
 def no_fatal_warnings : Flag<["--"], "no-fatal-warnings">;
 def start_group : Flag<["--"], "start-group">;
 def strip_all : Flag<["--"], "strip-all">;
 def version_script : Separate<["--"], "version-script">;
 def z : Separate<["-"], "z">;

lld/trunk/ELF/SymbolTable.cpp

case ELF32BEKind:
     addUndefinedSym<ELF32BE>(Name);
     break;
   case ELF64LEKind:
     addUndefinedSym<ELF64LE>(Name);
     break;
   case ELF64BEKind:
     addUndefinedSym<ELF64BE>(Name);
     break;
+  default:
+    llvm_unreachable("Invalid kind");
   }
 }
 
 template <class ELFT> void SymbolTable::addUndefinedSym(StringRef Name) {
   Undefined<ELFT>::SyntheticOptional.setVisibility(STV_HIDDEN);
   resolve<ELFT>(new (Alloc)
                     Undefined<ELFT>(Name, Undefined<ELFT>::SyntheticOptional));
 }
template <class ELFT> void SymbolTable::init(uint16_t EMachine) {
   // an undefined symbol in the .o files.
   // Given that the symbol is effectively unused, we just create a dummy
   // hidden one to avoid the undefined symbol error.
   addIgnoredSym<ELFT>("_GLOBAL_OFFSET_TABLE_");
 }
 
 template <class ELFT> void SymbolTable::addELFFile(ELFFileBase *File) {
   const ELFFileBase *Old = getFirstELF();
-  if (Old && !Old->isCompatibleWith(*File))
-    error(Twine(Old->getName() + " is incompatible with " + File->getName()));
-
   if (auto *O = dyn_cast<ObjectFileBase>(File))
     ObjectFiles.emplace_back(O);
   else if (auto *S = dyn_cast<SharedFile<ELFT>>(File))
     SharedFiles.emplace_back(S);
 
   if (!Old)
     init<ELFT>(File->getEMachine());
 
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;
 

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

lld/trunk/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:

lld/trunk/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 {{.*}}i686.so
 
 // REQUIRES: x86,arm