Index: ELF/Driver.h
===================================================================
--- ELF/Driver.h
+++ ELF/Driver.h
@@ -14,6 +14,7 @@
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Option/ArgList.h"
+#include <set>
 
 namespace lld {
 namespace elf2 {
@@ -25,20 +26,23 @@
 
 class LinkerDriver {
 public:
+  typedef std::vector<std::unique_ptr<Input>>::iterator InputVectorIterT;
+
   void main(ArrayRef<const char *> Args);
   void createFiles(llvm::opt::InputArgList &Args);
   template <class ELFT> void link(llvm::opt::InputArgList &Args);
 
   void addFile(StringRef Path);
 
-private:
-  template <template <class> class T>
-  std::unique_ptr<InputFile> createELFInputFile(MemoryBufferRef MB);
+  template <class ELFT>
+  InputVectorIterT handleGroup(SymbolTable<ELFT> &SymTab,
+                               InputVectorIterT Current);
 
+private:
   llvm::BumpPtrAllocator Alloc;
   bool WholeArchive = false;
-  std::vector<std::unique_ptr<InputFile>> Files;
-  std::vector<std::unique_ptr<ArchiveFile>> OwningArchives;
+  std::vector<std::unique_ptr<Input>> Files;
+  std::vector<std::unique_ptr<Input>> OwningArchives;
   std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
 };
 
Index: ELF/Driver.cpp
===================================================================
--- ELF/Driver.cpp
+++ ELF/Driver.cpp
@@ -182,11 +182,20 @@
       Config->ZOrigin = true;
   }
 
+  int groupUnMatchedCount = 0;
   for (auto *Arg : Args) {
     switch (Arg->getOption().getID()) {
     case OPT_l:
       addFile(searchLibrary(Arg->getValue()));
       break;
+    case OPT_start_group:
+      ++groupUnMatchedCount;
+      Files.push_back(std::unique_ptr<Input>(new Input(Input::StartGroup)));
+      break;
+    case OPT_end_group:
+      --groupUnMatchedCount;
+      Files.push_back(std::unique_ptr<Input>(new Input(Input::EndGroup)));
+      break;
     case OPT_INPUT:
     case OPT_script:
       addFile(Arg->getValue());
@@ -212,6 +221,9 @@
     }
   }
 
+  if (groupUnMatchedCount)
+    error("unmatched --start/--end group");
+
   if (Files.empty())
     error("no input files.");
 }
@@ -245,8 +257,19 @@
     Symtab.addIgnoredSym("_GLOBAL_OFFSET_TABLE_");
   }
 
-  for (std::unique_ptr<InputFile> &F : Files)
-    Symtab.addFile(std::move(F));
+  InputVectorIterT Start = Files.begin(), End = Files.end();
+  while (Start != End) {
+    InputVectorIterT Current = Start;
+    // Handle Groups if the linker finds a --start-group input.
+    if ((*Current)->type() == Input::StartGroup)
+      Start = handleGroup(Symtab, Current);
+    else if ((dyn_cast<InputFile>(Current->get()))->kind() ==
+             InputFile::ArchiveKind)
+      Symtab.addArchiveFile(Current->get());
+    else
+      Symtab.addFile(std::move(*Current));
+    ++Start;
+  }
 
   for (StringRef S : Config->Undefined)
     Symtab.addUndefinedOpt(S);
@@ -260,3 +283,44 @@
     markLive<ELFT>(&Symtab);
   writeResult<ELFT>(&Symtab);
 }
+
+template <class ELFT>
+LinkerDriver::InputVectorIterT
+LinkerDriver::handleGroup(SymbolTable<ELFT> &Symtab, InputVectorIterT Current) {
+  InputVectorIterT GroupStart = Current;
+  bool AddNewFiles = false;
+  do {
+    // Initialize AddNewFiles for every iteration.
+    AddNewFiles = false;
+    Current = GroupStart;
+    while (true) {
+      ++Current;
+      if (!(*Current))
+        continue;
+      if ((*Current)->type() == Input::EndGroup)
+        break;
+      Input::Type InputType = (*Current)->type();
+      Input *currentInput = Current->get();
+      switch (InputType) {
+      // Handle group inside another group. This is not usually seen but its not
+      // a lot of code to handle it.
+      case Input::StartGroup:
+        Current = handleGroup(Symtab, Current);
+        break;
+      case Input::EndGroup:
+        break;
+      case Input::File: {
+        InputFile *inputFile = dyn_cast<InputFile>(currentInput);
+        if (inputFile->kind() == InputFile::ArchiveKind)
+          // Archive files are needed to be looked up multiple times inside a
+          // Group. Dont transfer ownership.
+          AddNewFiles |= Symtab.addArchiveFile(currentInput);
+        else
+          AddNewFiles |= Symtab.addFile(std::move(*Current));
+        break;
+      }
+      } // End Case(Type)
+    }
+  } while (AddNewFiles);
+  return Current;
+}
Index: ELF/InputFiles.h
===================================================================
--- ELF/InputFiles.h
+++ ELF/InputFiles.h
@@ -30,16 +30,29 @@
 class Lazy;
 class SymbolBody;
 
+class Input {
+public:
+  enum Type { File, StartGroup, EndGroup };
+  Input(Type T) : InputType(T) {}
+  Type type() const { return InputType; }
+
+private:
+  const Type InputType;
+};
+
 // The root class of input files.
-class InputFile {
+class InputFile : public Input {
 public:
   enum Kind { ObjectKind, SharedKind, ArchiveKind };
   Kind kind() const { return FileKind; }
 
   StringRef getName() const { return MB.getBufferIdentifier(); }
 
+  static bool classof(const Input *F) { return true; }
+
 protected:
-  InputFile(Kind K, MemoryBufferRef M) : MB(M), FileKind(K) {}
+  InputFile(Kind K, MemoryBufferRef M)
+      : Input(Input::File), MB(M), FileKind(K) {}
   MemoryBufferRef MB;
 
 private:
Index: ELF/SymbolTable.h
===================================================================
--- ELF/SymbolTable.h
+++ ELF/SymbolTable.h
@@ -32,7 +32,10 @@
 public:
   SymbolTable();
 
-  void addFile(std::unique_ptr<InputFile> File);
+  bool addFile(std::unique_ptr<Input> I);
+
+  // Add archive file without transferring ownership.
+  bool addArchiveFile(Input *I);
 
   bool shouldUseRela() const;
 
@@ -60,15 +63,13 @@
 private:
   Symbol *insert(SymbolBody *New);
   void addELFFile(ELFFileBase<ELFT> *File);
-  void addLazy(Lazy *New);
+  bool addLazy(Lazy *New);
   void addMemberFile(Lazy *Body);
-  void checkCompatibility(std::unique_ptr<InputFile> &File);
+  void checkCompatibility(InputFile *File);
   void resolve(SymbolBody *Body);
   void reportConflict(const Twine &Message, const SymbolBody &Old,
                       const SymbolBody &New, bool Warning);
 
-  std::vector<std::unique_ptr<InputFile>> ArchiveFiles;
-
   // The order the global symbols are in is not defined. We can use an arbitrary
   // order, but it has to be reproducible. That is true even when cross linking.
   // The default hashing of StringRef produces different results on 32 and 64
Index: ELF/SymbolTable.cpp
===================================================================
--- ELF/SymbolTable.cpp
+++ ELF/SymbolTable.cpp
@@ -34,26 +34,36 @@
 }
 
 template <class ELFT>
-void SymbolTable<ELFT>::addFile(std::unique_ptr<InputFile> File) {
-  checkCompatibility(File);
+bool SymbolTable<ELFT>::addFile(std::unique_ptr<Input> I) {
+  bool AddNewMember = false;
+  InputFile *File = dyn_cast<InputFile>(I.get());
 
-  if (auto *AF = dyn_cast<ArchiveFile>(File.get())) {
-    ArchiveFiles.emplace_back(std::move(File));
-    AF->parse();
-    for (Lazy &Sym : AF->getLazySymbols())
-      addLazy(&Sym);
-    return;
-  }
+  checkCompatibility(File);
 
-  if (auto *S = dyn_cast<SharedFile<ELFT>>(File.get())) {
+  if (auto *S = dyn_cast<SharedFile<ELFT>>(File)) {
     S->parseSoName();
     if (!IncludedSoNames.insert(S->getSoName()).second)
-      return;
+      return AddNewMember;
     S->parse();
   } else {
-    cast<ObjectFile<ELFT>>(File.get())->parse(Comdats);
+    cast<ObjectFile<ELFT>>(File)->parse(Comdats);
   }
-  addELFFile(cast<ELFFileBase<ELFT>>(File.release()));
+  addELFFile(cast<ELFFileBase<ELFT>>(dyn_cast<InputFile>(I.release())));
+  return true;
+}
+
+template <class ELFT> bool SymbolTable<ELFT>::addArchiveFile(Input *I) {
+  bool AddNewMember = false;
+  InputFile *File = dyn_cast<InputFile>(I);
+
+  checkCompatibility(File);
+
+  if (auto *AF = dyn_cast<ArchiveFile>(File)) {
+    AF->parse();
+    for (Lazy &Sym : AF->getLazySymbols())
+      AddNewMember |= addLazy(&Sym);
+  }
+  return AddNewMember;
 }
 
 template <class ELFT>
@@ -201,13 +211,13 @@
   return It->second->Body;
 }
 
-template <class ELFT> void SymbolTable<ELFT>::addLazy(Lazy *New) {
+template <class ELFT> bool SymbolTable<ELFT>::addLazy(Lazy *New) {
   Symbol *Sym = insert(New);
   if (Sym->Body == New)
-    return;
+    return false;
   SymbolBody *Existing = Sym->Body;
   if (Existing->isDefined() || Existing->isLazy())
-    return;
+    return false;
   Sym->Body = New;
   assert(Existing->isUndefined() && "Unexpected symbol kind.");
 
@@ -221,14 +231,15 @@
   if (Existing->isWeak()) {
     New->setUsedInRegularObj();
     New->setWeak();
-    return;
+    return false;
   }
   addMemberFile(New);
+  return true;
 }
 
 template <class ELFT>
-void SymbolTable<ELFT>::checkCompatibility(std::unique_ptr<InputFile> &File) {
-  auto *E = dyn_cast<ELFFileBase<ELFT>>(File.get());
+void SymbolTable<ELFT>::checkCompatibility(InputFile *File) {
+  auto *E = dyn_cast<ELFFileBase<ELFT>>(File);
   if (!E)
     return;
   if (E->getELFKind() == Config->EKind && E->getEMachine() == Config->EMachine)
Index: ELF/Target.cpp
===================================================================
--- ELF/Target.cpp
+++ ELF/Target.cpp
@@ -118,17 +118,6 @@
                    uint64_t SA) const override;
 };
 
-template <class ELFT> class HexagonTargetInfo final : public TargetInfo {
-public:
-  HexagonTargetInfo();
-  void writePltEntry(uint8_t *Buf, uint64_t GotEntryAddr,
-                     uint64_t PltEntryAddr) const override;
-  bool relocNeedsGot(uint32_t Type, const SymbolBody &S) const override;
-  bool relocNeedsPlt(uint32_t Type, const SymbolBody &S) const override;
-  void relocateOne(uint8_t *Buf, uint8_t *BufEnd, const void *RelP,
-                   uint32_t Type, uint64_t BaseAddr,
-                   uint64_t SA) const override;
-};
 } // anonymous namespace
 
 TargetInfo *createTarget() {
Index: test/elf2/Inputs/startendgroup/a.s
===================================================================
--- /dev/null
+++ test/elf2/Inputs/startendgroup/a.s
@@ -0,0 +1,5 @@
+	.text
+	.globl	main
+	.type	main,@function
+main:
+	jmp	bar
Index: test/elf2/Inputs/startendgroup/b1.s
===================================================================
--- /dev/null
+++ test/elf2/Inputs/startendgroup/b1.s
@@ -0,0 +1,5 @@
+	.text
+	.weak	bar
+	.type	bar,@function
+bar:
+	jmp	baz
Index: test/elf2/Inputs/startendgroup/b11.s
===================================================================
--- /dev/null
+++ test/elf2/Inputs/startendgroup/b11.s
@@ -0,0 +1,5 @@
+	.text
+	.globl	moo
+	.type	moo,@function
+moo:
+	retq
Index: test/elf2/Inputs/startendgroup/b2.s
===================================================================
--- /dev/null
+++ test/elf2/Inputs/startendgroup/b2.s
@@ -0,0 +1,5 @@
+	.text
+	.weak	boo
+	.type	boo,@function
+boo:
+	callq	moo
Index: test/elf2/Inputs/startendgroup/c.s
===================================================================
--- /dev/null
+++ test/elf2/Inputs/startendgroup/c.s
@@ -0,0 +1,5 @@
+	.text
+	.weak	baz
+	.type	baz,@function
+baz:
+	jmp	boo
Index: test/elf2/startendgroup.s
===================================================================
--- /dev/null
+++ test/elf2/startendgroup.s
@@ -0,0 +1,19 @@
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/startendgroup/a.s -o %t1.a.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/startendgroup/c.s -o %t1.c.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/startendgroup/b1.s -o %t1.b1.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/startendgroup/b2.s -o %t1.b2.o
+# RUN: llvm-mc -filetype=obj -triple=x86_64-pc-linux %S/Inputs/startendgroup/b11.s -o %t1.b11.o
+# RUN: llvm-ar rcs %t1.libb1.a %t1.b1.o %t1.b11.o
+# RUN: llvm-ar rcs %t1.libb2.a %t1.b2.o
+# RUN: llvm-ar rcs %t1.libc.a %t1.c.o
+# RUN: ld.lld2 --noinhibit-exec %t1.a.o --start-group %t1.libb1.a %t1.libb2.a %t1.libc.a --end-group -o %toutsimple
+# RUN: llvm-nm -n %toutsimple | FileCheck %s
+# RUN: ld.lld2 --noinhibit-exec %t1.a.o --start-group %t1.libb1.a --start-group %t1.libb2.a --end-group %t1.libc.a --end-group -o %tout
+# RUN: llvm-nm -n %tout | FileCheck %s
+# REQUIRES: x86
+
+#CHECK: main
+#CHECK: bar
+#CHECK: baz
+#CHECK: boo
+#CHECK: moo