Index: ELF/Config.h
===================================================================
--- ELF/Config.h
+++ ELF/Config.h
@@ -10,14 +10,23 @@
 #ifndef LLD_ELF_CONFIG_H
 #define LLD_ELF_CONFIG_H
 
+#include "llvm/ADT/Optional.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/Support/ELF.h"
+#include <cstdint>
 
 #include <vector>
 
 namespace lld {
 namespace elf2 {
 
+enum ELFKind { ELF32LEKind, ELF32BEKind, ELF64LEKind, ELF64BEKind };
+
 struct Configuration {
+  bool is64Bits() const {
+    return *ElfKind == ELF64BEKind || *ElfKind == ELF64LEKind;
+  }
+
   llvm::StringRef OutputFile;
   llvm::StringRef DynamicLinker;
   std::string RPath;
@@ -28,6 +37,9 @@
   bool DiscardNone = false;
   bool ExportDynamic = false;
   bool NoInhibitExec = false;
+
+  llvm::Optional<ELFKind> ElfKind;
+  uint16_t EMachine = llvm::ELF::EM_NONE;
 };
 
 extern Configuration *Config;
Index: ELF/Driver.cpp
===================================================================
--- ELF/Driver.cpp
+++ ELF/Driver.cpp
@@ -15,6 +15,7 @@
 #include "Writer.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/StringExtras.h"
+#include "llvm/Object/ELF.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/Path.h"
 
@@ -47,17 +48,53 @@
   return MBRef;
 }
 
-static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB) {
+static uint16_t getElfMachineType(StringRef Object) {
+  using namespace object;
+
+  // First three fields of 32-bit and 64-bit ELF headers are of equal
+  // size, so no matter which one to use, but care about endianness.
+  if (Object.size() < (ELF::EI_NIDENT + 2 * sizeof(ELF::Elf32_Half)))
+    return ELF::EM_NONE;
+  if ((uint8_t)Object[ELF::EI_DATA] == ELF::ELFDATA2MSB)
+    return ((const Elf_Ehdr_Impl<ELF32BE> *)Object.data())->e_machine;
+  return ((const Elf_Ehdr_Impl<ELF32LE> *)Object.data())->e_machine;
+}
+
+static void configureTarget(ELFKind ElfKind, uint16_t EMachine) {
+  Config->ElfKind = ElfKind;
+  Config->EMachine = EMachine;
+}
+
+template <template <class> class T>
+static std::unique_ptr<InputFile> createELFFile(MemoryBufferRef MB,
+                                                const char *&TargetSource) {
+  std::unique_ptr<ELFFileBase> File = createELFFile<T>(MB);
+  const ELFKind ElfKind = File->getELFKind();
+  const uint16_t EMachine = getElfMachineType(MB.getBuffer());
+
+  // Grab target from the first input file if wasn't set by -m option.
+  if (!Config->ElfKind.hasValue()) {
+    configureTarget(ElfKind, EMachine);
+    TargetSource = MB.getBufferIdentifier().data();
+    return std::move(File);
+  }
+
+  if (ElfKind != *Config->ElfKind || EMachine != Config->EMachine)
+    error(Twine(MB.getBufferIdentifier() + " is incompatible with " +
+                TargetSource));
+  return std::move(File);
+}
+
+static std::unique_ptr<InputFile> createFile(MemoryBufferRef MB,
+                                             const char *&TargetSource) {
   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 createELFFile<SharedFile>(MB, TargetSource);
+  return createELFFile<ObjectFile>(MB, TargetSource);
 }
 
 // Searches a given library from input search paths, which are filled
@@ -82,6 +119,30 @@
   error(Twine("Unable to find library -l") + Path);
 }
 
+static void applyEmulation(StringRef Emul) {
+  using namespace ELF;
+
+  struct Emulation {
+    const char *Name;
+    ELFKind ElfKind;
+    uint16_t EMachine;
+  };
+  static const Emulation Emulations[] = {
+      {"elf_i386", ELF32LEKind, EM_386},
+      {"elf_x86_64", ELF64LEKind, EM_X86_64},
+      {"elf32ppc", ELF32BEKind, EM_PPC},
+      {"elf64ppc", ELF64BEKind, EM_PPC64},
+  };
+
+  for (auto E : Emulations) {
+    if (Emul == E.Name) {
+      configureTarget(E.ElfKind, E.EMachine);
+      return;
+    }
+  }
+  error(Twine("Unknown emulation: ") + Emul);
+}
+
 void LinkerDriver::link(ArrayRef<const char *> ArgsArr) {
   // Parse command line options.
   opt::InputArgList Args = Parser.parse(ArgsArr);
@@ -123,6 +184,11 @@
   if (Args.hasArg(OPT_noinhibit_exec))
     Config->NoInhibitExec = true;
 
+  // Handle -m emulation
+  const char *TargetSource = "target architecture";
+  if (auto *Arg = Args.getLastArg(OPT_emulation))
+    applyEmulation(Arg->getValue());
+
   // Create a list of input files.
   std::vector<MemoryBufferRef> Inputs;
 
@@ -144,13 +210,12 @@
   // 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);
+    std::unique_ptr<InputFile> File = createFile(MB, TargetSource);
     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;
Index: ELF/InputFiles.h
===================================================================
--- ELF/InputFiles.h
+++ ELF/InputFiles.h
@@ -10,6 +10,7 @@
 #ifndef LLD_ELF_INPUT_FILES_H
 #define LLD_ELF_INPUT_FILES_H
 
+#include "Config.h"
 #include "InputSection.h"
 #include "Error.h"
 #include "Symbols.h"
@@ -48,8 +49,6 @@
   const Kind FileKind;
 };
 
-enum ELFKind { ELF32LEKind, ELF32BEKind, ELF64LEKind, ELF64BEKind };
-
 class ELFFileBase : public InputFile {
 public:
   explicit ELFFileBase(Kind K, ELFKind EKind, MemoryBufferRef M)
Index: ELF/Options.td
===================================================================
--- ELF/Options.td
+++ ELF/Options.td
@@ -49,3 +49,6 @@
 
 def alias_l : Joined<["--"], "library=">,
      Alias<l>;
+
+def emulation : Separate<["-"], "m">,
+     HelpText<"Set target emulation">;
Index: ELF/SymbolTable.cpp
===================================================================
--- ELF/SymbolTable.cpp
+++ ELF/SymbolTable.cpp
@@ -23,8 +23,7 @@
 SymbolTable::SymbolTable() {}
 
 bool SymbolTable::shouldUseRela() const {
-  ELFKind K = getFirstELF()->getELFKind();
-  return K == ELF64LEKind || K == ELF64BEKind;
+  return Config->is64Bits();
 }
 
 void SymbolTable::addFile(std::unique_ptr<InputFile> File) {
@@ -98,7 +97,7 @@
     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)) {
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -501,7 +501,7 @@
   // 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 =
Index: test/elf2/basic.s
===================================================================
--- test/elf2/basic.s
+++ test/elf2/basic.s
@@ -205,3 +205,6 @@
 # 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
Index: test/elf2/emulation.s
===================================================================
--- /dev/null
+++ test/elf2/emulation.s
@@ -0,0 +1,128 @@
+# 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:
Index: test/elf2/incompatible.s
===================================================================
--- test/elf2/incompatible.s
+++ test/elf2/incompatible.s
@@ -5,22 +5,42 @@
 
 // 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