Index: test/tools/llvm-objcopy/basic-strip.test
===================================================================
--- test/tools/llvm-objcopy/basic-strip.test
+++ test/tools/llvm-objcopy/basic-strip.test
@@ -21,12 +21,9 @@
   - Name:            .gnu.warning.foo
     Type:            SHT_PROGBITS
 
-# CHECK: SectionHeaderCount: 8
+# CHECK: SectionHeaderCount: 5
 
 # CHECK: Name: .bss
 # CHECK: Name: .text
-# CHECK: Name: .blarg
 # CHECK: Name: .gnu.warning.foo
-# CHECK: Name: .symtab
-# CHECK: Name: .strtab
 # CHECK: Name: .shstrtab
Index: tools/llvm-objcopy/llvm-objcopy.cpp
===================================================================
--- tools/llvm-objcopy/llvm-objcopy.cpp
+++ tools/llvm-objcopy/llvm-objcopy.cpp
@@ -25,6 +25,7 @@
 #include "llvm/Support/ErrorOr.h"
 #include "llvm/Support/FileOutputBuffer.h"
 #include "llvm/Support/ManagedStatic.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/PrettyStackTrace.h"
 #include "llvm/Support/Signals.h"
 #include "llvm/Support/raw_ostream.h"
@@ -71,48 +72,6 @@
 
 } // end namespace llvm
 
-static cl::opt<std::string> InputFilename(cl::Positional, cl::desc("<input>"));
-static cl::opt<std::string> OutputFilename(cl::Positional, cl::desc("<output>"),
-                                    cl::init("-"));
-static cl::opt<std::string>
-    OutputFormat("O", cl::desc("Set output format to one of the following:"
-                               "\n\tbinary"));
-static cl::list<std::string> ToRemove("remove-section",
-                                      cl::desc("Remove <section>"),
-                                      cl::value_desc("section"));
-static cl::alias ToRemoveA("R", cl::desc("Alias for remove-section"),
-                           cl::aliasopt(ToRemove));
-static cl::opt<bool> StripAll(
-    "strip-all",
-    cl::desc(
-        "Removes non-allocated sections other than .gnu.warning* sections"));
-static cl::opt<bool>
-    StripAllGNU("strip-all-gnu",
-                cl::desc("Removes symbol, relocation, and debug information"));
-static cl::list<std::string> Keep("keep", cl::desc("Keep <section>"),
-                                  cl::value_desc("section"));
-static cl::list<std::string> OnlyKeep("only-keep",
-                                      cl::desc("Remove all but <section>"),
-                                      cl::value_desc("section"));
-static cl::alias OnlyKeepA("j", cl::desc("Alias for only-keep"),
-                           cl::aliasopt(OnlyKeep));
-static cl::opt<bool> StripDebug("strip-debug",
-                                cl::desc("Removes all debug information"));
-static cl::opt<bool> StripSections("strip-sections",
-                                   cl::desc("Remove all section headers"));
-static cl::opt<bool> StripNonAlloc("strip-non-alloc",
-                                   cl::desc("Remove all non-allocated sections"));
-static cl::opt<bool>
-    StripDWO("strip-dwo", cl::desc("Remove all DWARF .dwo sections from file"));
-static cl::opt<bool> ExtractDWO(
-    "extract-dwo",
-    cl::desc("Remove all sections that are not DWARF .dwo sections from file"));
-static cl::opt<std::string>
-    SplitDWO("split-dwo",
-             cl::desc("Equivalent to extract-dwo on the input file to "
-                      "<dwo-file>, then strip-dwo on the input file"),
-             cl::value_desc("dwo-file"));
-
 using SectionPred = std::function<bool(const SectionBase &Sec)>;
 
 bool IsDWOSection(const SectionBase &Sec) {
@@ -135,8 +94,8 @@
   Expected<std::unique_ptr<FileOutputBuffer>> BufferOrErr =
       FileOutputBuffer::create(File, Obj.totalSize(),
                                FileOutputBuffer::F_executable);
-  handleAllErrors(BufferOrErr.takeError(), [](const ErrorInfoBase &) {
-    error("failed to open " + OutputFilename);
+  handleAllErrors(BufferOrErr.takeError(), [=](const ErrorInfoBase &) {
+    error("failed to open " + File);
   });
   Buffer = std::move(*BufferOrErr);
 
@@ -157,6 +116,26 @@
   WriteObjectFile(DWOFile, File);
 }
 
+template <class ELFT>
+struct CopyConfig {
+  StringRef OutputFilename;
+  StringRef OutputFormat;
+  const ELFObjectFile<ELFT> &ObjFile;
+  std::vector<StringRef> ToRemove;
+  std::vector<StringRef> Keep;
+  std::vector<StringRef> OnlyKeep;
+  bool StripAll;
+  bool StripAllGNU;
+  bool StripSections;
+  bool StripDebug;
+  bool StripNonAlloc;
+  bool StripDWO;
+  bool ExtractDWO;
+  Optional<StringRef> SplitDWO;
+  CopyConfig(const ELFObjectFile<ELFT> &ObjFile) : ObjFile(ObjFile) {}
+  void copyBinary();
+};
+
 // This function handles the high level operations of GNU objcopy including
 // handling command line options. It's important to outline certain properties
 // we expect to hold of the command line operations. Any operation that "keeps"
@@ -165,31 +144,31 @@
 // depend a) on the order the options occur in or b) on some opaque priority
 // system. The only priority is that keeps/copies overrule removes.
 template <class ELFT>
-void CopyBinary(const ELFObjectFile<ELFT> &ObjFile) {
+void CopyConfig<ELFT>::copyBinary() {
   std::unique_ptr<Object<ELFT>> Obj;
 
-  if (!OutputFormat.empty() && OutputFormat != "binary")
+  if (OutputFormat != "elf" && OutputFormat != "binary")
     error("invalid output format '" + OutputFormat + "'");
-  if (!OutputFormat.empty() && OutputFormat == "binary")
+  if (OutputFormat == "binary")
     Obj = llvm::make_unique<BinaryObject<ELFT>>(ObjFile);
   else
     Obj = llvm::make_unique<ELFObject<ELFT>>(ObjFile);
 
-  if (!SplitDWO.empty())
-    SplitDWOToFile<ELFT>(ObjFile, SplitDWO.getValue());
+  if (SplitDWO)
+    SplitDWOToFile<ELFT>(ObjFile, *SplitDWO);
 
   SectionPred RemovePred = [](const SectionBase &) { return false; };
 
   // Removes:
 
   if (!ToRemove.empty()) {
-    RemovePred = [&](const SectionBase &Sec) {
+    RemovePred = [&, this](const SectionBase &Sec) {
       return std::find(std::begin(ToRemove), std::end(ToRemove), Sec.Name) !=
              std::end(ToRemove);
     };
   }
 
-  if (StripDWO || !SplitDWO.empty())
+  if (StripDWO || SplitDWO)
     RemovePred = [RemovePred](const SectionBase &Sec) {
       return IsDWOSection(Sec) || RemovePred(Sec);
     };
@@ -253,7 +232,7 @@
   // Explicit copies:
 
   if (!OnlyKeep.empty()) {
-    RemovePred = [RemovePred, &Obj](const SectionBase &Sec) {
+    RemovePred = [RemovePred, &Obj, this](const SectionBase &Sec) {
       // Explicitly keep these sections regardless of previous removes.
       if (std::find(std::begin(OnlyKeep), std::end(OnlyKeep), Sec.Name) !=
           std::end(OnlyKeep))
@@ -277,7 +256,7 @@
   }
 
   if (!Keep.empty()) {
-    RemovePred = [RemovePred](const SectionBase &Sec) {
+    RemovePred = [RemovePred, this](const SectionBase &Sec) {
       // Explicitly keep these sections regardless of previous removes.
       if (std::find(std::begin(Keep), std::end(Keep), Sec.Name) !=
           std::end(Keep))
@@ -289,7 +268,108 @@
 
   Obj->removeSections(RemovePred);
   Obj->finalize();
-  WriteObjectFile(*Obj, OutputFilename.getValue());
+  WriteObjectFile(*Obj, OutputFilename);
+}
+
+// This namespace hides our flags so that only our driver functions see them.
+namespace flags {
+
+static cl::opt<std::string> InputFilename(cl::Positional, cl::desc("<input>"));
+static cl::opt<std::string> OutputFilename(cl::Positional, cl::desc("<output>"));
+static cl::opt<std::string>
+    OutputFormat("O", cl::desc("Set output format to one of the following:"
+                               "\n\tbinary\n\telf"), cl::init("elf"));
+static cl::list<std::string> ToRemove("remove-section",
+                                      cl::desc("Remove <section>"),
+                                      cl::value_desc("section"));
+static cl::alias ToRemoveA("R", cl::desc("Alias for remove-section"),
+                           cl::aliasopt(ToRemove));
+static cl::opt<bool> StripAll(
+    "strip-all",
+    cl::desc(
+        "Removes non-allocated sections other than .gnu.warning* sections"));
+static cl::opt<bool>
+    StripAllGNU("strip-all-gnu",
+                cl::desc("Removes symbol, relocation, and debug information"));
+static cl::list<std::string> Keep("keep", cl::desc("Keep <section>"),
+                                  cl::value_desc("section"));
+static cl::list<std::string> OnlyKeep("only-keep",
+                                      cl::desc("Remove all but <section>"),
+                                      cl::value_desc("section"));
+static cl::alias OnlyKeepA("j", cl::desc("Alias for only-keep"),
+                           cl::aliasopt(OnlyKeep));
+static cl::opt<bool> StripDebug("strip-debug",
+                                cl::desc("Removes all debug information"));
+static cl::opt<bool> StripSections("strip-sections",
+                                   cl::desc("Remove all section headers"));
+static cl::opt<bool> StripNonAlloc("strip-non-alloc",
+                                   cl::desc("Remove all non-allocated sections"));
+static cl::opt<bool>
+    StripDWO("strip-dwo", cl::desc("Remove all DWARF .dwo sections from file"));
+static cl::opt<bool> ExtractDWO(
+    "extract-dwo",
+    cl::desc("Remove all sections that are not DWARF .dwo sections from file"));
+static cl::opt<std::string>
+    SplitDWO("split-dwo",
+             cl::desc("Equivalent to extract-dwo on the input file to "
+                      "<dwo-file>, then strip-dwo on the input file"),
+             cl::value_desc("dwo-file"));
+
+}
+
+// This nameless namespace is just to scope the useage of the flags namespace.
+namespace {
+
+using namespace flags;
+
+template <class ELFT>
+void CommonConfig(CopyConfig<ELFT>& Config) {
+  if (OutputFilename.empty())
+    Config.OutputFilename = InputFilename;
+  else
+    Config.OutputFilename = OutputFilename;
+  Config.OutputFormat = OutputFormat.getValue();
+  Config.ExtractDWO = ExtractDWO;
+  Config.Keep.insert(std::end(Config.Keep), std::begin(Keep), std::end(Keep));
+  Config.OnlyKeep.insert(std::end(Config.OnlyKeep), std::begin(OnlyKeep), std::end(OnlyKeep));
+  Config.ToRemove.insert(std::end(Config.ToRemove), std::begin(ToRemove), std::end(ToRemove));
+  if(!SplitDWO.empty())
+    Config.SplitDWO = SplitDWO;
+  Config.StripDWO = StripDWO;
+  Config.StripSections = StripSections;
+  Config.StripAllGNU = StripAllGNU;
+  Config.StripDebug = StripDebug;
+  Config.StripNonAlloc = StripNonAlloc;
+}
+
+template <class ELFT>
+void Strip(const ELFObjectFile<ELFT>& ObjFile) {
+  CopyConfig<ELFT> Config(ObjFile);
+  CommonConfig(Config);
+  Config.StripAll = StripAll ||
+                    !(StripAllGNU || StripDebug || StripDWO || StripNonAlloc ||
+                      StripSections);
+  Config.copyBinary();
+}
+
+template <class ELFT>
+void Objcopy(const ELFObjectFile<ELFT>& ObjFile) {
+  CopyConfig<ELFT> Config(ObjFile);
+  CommonConfig(Config);
+  Config.StripAll = StripAll;
+  Config.copyBinary();
+}
+
+}
+
+template <class ELFT>
+void InvokeMain(const ELFObjectFile<ELFT>& ObjFile) {
+  StringRef Stem = sys::path::stem(ToolName);
+  if (Stem.find("strip") != StringRef::npos) {
+    Strip(ObjFile);
+  } else {
+    Objcopy(ObjFile);
+  }
 }
 
 int main(int argc, char **argv) {
@@ -308,19 +388,19 @@
     reportError(InputFilename, BinaryOrErr.takeError());
   Binary &Binary = *BinaryOrErr.get().getBinary();
   if (auto *o = dyn_cast<ELFObjectFile<ELF64LE>>(&Binary)) {
-    CopyBinary(*o);
+    InvokeMain(*o);
     return 0;
   }
   if (auto *o = dyn_cast<ELFObjectFile<ELF32LE>>(&Binary)) {
-    CopyBinary(*o);
+    InvokeMain(*o);
     return 0;
   }
   if (auto *o = dyn_cast<ELFObjectFile<ELF64BE>>(&Binary)) {
-    CopyBinary(*o);
+    InvokeMain(*o);
     return 0;
   }
   if (auto *o = dyn_cast<ELFObjectFile<ELF32BE>>(&Binary)) {
-    CopyBinary(*o);
+    InvokeMain(*o);
     return 0;
   }
   reportError(InputFilename, object_error::invalid_file_type);