Index: ELF/CMakeLists.txt
===================================================================
--- ELF/CMakeLists.txt
+++ ELF/CMakeLists.txt
@@ -5,6 +5,7 @@
 add_lld_library(lldELF
   Driver.cpp
   DriverUtils.cpp
+  DynamicList.cpp
   Error.cpp
   ICF.cpp
   InputFiles.cpp
Index: ELF/Config.h
===================================================================
--- ELF/Config.h
+++ ELF/Config.h
@@ -56,6 +56,7 @@
   bool BsymbolicFunctions;
   bool BuildId;
   bool Demangle = true;
+  bool DynamicList;
   bool DisableVerify;
   bool DiscardAll;
   bool DiscardLocals;
Index: ELF/Driver.h
===================================================================
--- ELF/Driver.h
+++ ELF/Driver.h
@@ -30,6 +30,7 @@
 private:
   std::vector<MemoryBufferRef> getArchiveMembers(MemoryBufferRef MB);
   void readConfigs(llvm::opt::InputArgList &Args);
+  void readDynamicList(StringRef Path);
   void createFiles(llvm::opt::InputArgList &Args);
   template <class ELFT> void link(llvm::opt::InputArgList &Args);
 
Index: ELF/Driver.cpp
===================================================================
--- ELF/Driver.cpp
+++ ELF/Driver.cpp
@@ -9,6 +9,7 @@
 
 #include "Driver.h"
 #include "Config.h"
+#include "DynamicList.h"
 #include "Error.h"
 #include "ICF.h"
 #include "InputFiles.h"
@@ -38,9 +39,11 @@
   Configuration C;
   LinkerDriver D;
   LinkerScript LS;
+  DynamicList DL;
   Config = &C;
   Driver = &D;
   Script = &LS;
+  DynList = &DL;
   Driver->main(Args);
   return !HasError;
 }
@@ -133,6 +136,19 @@
   }
 }
 
+void LinkerDriver::readDynamicList(StringRef Path) {
+  using namespace llvm::sys::fs;
+  auto MBOrErr = MemoryBuffer::getFile(Path);
+  if (!MBOrErr) {
+    error(MBOrErr, "cannot open " + Path);
+    return;
+  }
+  std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
+  MemoryBufferRef MBRef = MB->getMemBufferRef();
+  OwningMBs.push_back(std::move(MB)); // take MB ownership
+  DynList->read(MBRef);
+}
+
 // Add a given library by searching it from input search paths.
 void LinkerDriver::addLibrary(StringRef Name) {
   std::string Path = searchLibrary(Name);
@@ -299,6 +315,9 @@
   Config->OutputFile = getString(Args, OPT_o);
   Config->SoName = getString(Args, OPT_soname);
   Config->Sysroot = getString(Args, OPT_sysroot);
+  Config->DynamicList = Args.hasArg(OPT_dynamic_list);
+  if (Config->DynamicList)
+    readDynamicList(getString(Args, OPT_dynamic_list));
 
   Config->Optimize = getInteger(Args, OPT_O, 0);
   Config->LtoO = getInteger(Args, OPT_lto_O, 2);
Index: ELF/DynamicList.h
===================================================================
--- /dev/null
+++ ELF/DynamicList.h
@@ -0,0 +1,42 @@
+//===- DynamicList.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_DYNAMIC_LIST_H
+#define LLD_ELF_DYNAMIC_LIST_H
+
+#include "lld/Core/LLVM.h"
+#include "llvm/ADT/StringSet.h"
+#include "llvm/Support/Allocator.h"
+#include "llvm/Support/MemoryBuffer.h"
+
+namespace lld {
+namespace elf {
+
+class DynamicListParser;
+
+class DynamicList {
+  friend class DynamicListParser;
+
+public:
+  void read(MemoryBufferRef MB);
+
+  bool isInDynamicList(StringRef Symbol);
+
+private:
+  enum GlobLanguage { LANGUAGE_C, LANGUAGE_CXX, LANGUAGE_NOT_SUPPORTED };
+
+  llvm::StringSet<> ExactMatch;
+};
+
+extern DynamicList *DynList;
+
+} // namespace elf
+} // namespace lld
+
+#endif
Index: ELF/DynamicList.cpp
===================================================================
--- /dev/null
+++ ELF/DynamicList.cpp
@@ -0,0 +1,131 @@
+//===- LinkerScript.cpp ---------------------------------------------------===//
+//
+//                             The LLVM Linker
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file contains the parser/evaluator of the linker script.
+// It does not construct an AST but consume linker script directives directly.
+// Results are written to Driver or Config object.
+//
+//===----------------------------------------------------------------------===//
+
+#include "DynamicList.h"
+#include "Config.h"
+#include "Driver.h"
+#include "ScriptParser.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "llvm/Support/Path.h"
+#include "llvm/Support/StringSaver.h"
+
+using namespace llvm;
+using namespace llvm::object;
+using namespace lld;
+using namespace lld::elf;
+
+DynamicList *elf::DynList;
+
+// Parse the --dynamic-list argument.  A dynamic list is in the form
+//
+//  { symbol1; symbol2; extern "C++" { symbol3; namespace::symbol4 }; }
+//
+// With the ';' after symbol4 being optional.  Multiple groups can be
+// defined in the same file and they are merged in only one definition.
+
+class elf::DynamicListParser final : public ScriptParserBase {
+public:
+  DynamicListParser(StringRef S) : ScriptParserBase(S) {}
+
+  void run() final;
+
+private:
+  void readGroup();
+  void readLanguageGroup(DynamicList::GlobLanguage);
+  void readEntry(DynamicList::GlobLanguage);
+  DynamicList::GlobLanguage SupportedLanguage(StringRef Lang);
+};
+
+// Returns if the language defined inside quotes with extern keyword is
+// supported (currently only 'C++').
+DynamicList::GlobLanguage DynamicListParser::SupportedLanguage(StringRef Lang) {
+  if (Lang == "C++")
+    return DynamicList::LANGUAGE_CXX;
+  return DynamicList::LANGUAGE_NOT_SUPPORTED;
+}
+
+// Parses the groups defined by 'export 'LANG' { ... }'.  For such symbols
+// the language defined is used to mark with demangle to use in the match
+// function.
+void DynamicListParser::readLanguageGroup(DynamicList::GlobLanguage Lang) {
+  expect("{");
+  while (!Error) {
+    readEntry(Lang);
+    StringRef Tok = peek();
+    if (Tok == "}") {
+      next();
+      break;
+    }
+    expect(";");
+    if (peek() == "}") {
+      next();
+      break;
+    }
+  }
+}
+
+// Parse the default group definition using C language symbol name.
+void DynamicListParser::readGroup() {
+  expect("{");
+  while (!Error) {
+    readEntry(DynamicList::LANGUAGE_C);
+    expect(";");
+    if (peek() == "}") {
+      next();
+      break;
+    }
+  }
+  expect(";");
+}
+
+void DynamicListParser::readEntry(DynamicList::GlobLanguage Lang) {
+  // An entry may specify the language it should bind with. For instance:
+  // - extern "C++" { namespace::sym };
+  // It instructs the demangled symbol 'sym' should be exported as well.
+  StringRef Entry = next();
+  if (Entry == "extern") {
+    StringRef Tok = peek();
+    // And 'extern' itself can be used a symbol name.
+    if (Tok == ";") {
+      DynList->ExactMatch.insert(Entry);
+    } else {
+      StringRef Tok = next();
+      DynamicList::GlobLanguage Lang = SupportedLanguage(Tok);
+      if (Lang != DynamicList::LANGUAGE_NOT_SUPPORTED)
+        readLanguageGroup(Lang);
+      else
+        setError("invalid language in extern definition (" + Tok + ")");
+    }
+  } else {
+    DynList->ExactMatch.insert(Entry);
+  }
+}
+
+void DynamicListParser::run() {
+  while (!atEOF()) {
+    readGroup();
+  }
+}
+
+void DynamicList::read(MemoryBufferRef MB) {
+  DynamicListParser(MB.getBuffer()).run();
+}
+
+bool DynamicList::isInDynamicList(StringRef Symbol) {
+  if (ExactMatch.find(Symbol) != ExactMatch.end())
+    return true;
+  return false;
+}
Index: ELF/Options.td
===================================================================
--- ELF/Options.td
+++ ELF/Options.td
@@ -152,6 +152,9 @@
 def z : JoinedOrSeparate<["-"], "z">, MetaVarName<"<option>">,
   HelpText<"Linker option extensions">;
 
+def dynamic_list : Separate<["--", "-"], "dynamic-list">,
+  HelpText<"Dynamic list to use">;
+
 // Aliases
 def alias_Bdynamic_call_shared: Flag<["-"], "call_shared">, Alias<Bdynamic>;
 def alias_Bdynamic_dy: Flag<["-"], "dy">, Alias<Bdynamic>;
@@ -161,6 +164,7 @@
 def alias_L__library_path : Joined<["--"], "library-path=">, Alias<L>;
 def alias_discard_all_x: Flag<["-"], "x">, Alias<discard_all>;
 def alias_discard_locals_X: Flag<["-"], "X">, Alias<discard_locals>;
+def alias_dynamic_list: Joined<["--", "-"], "dynamic-list=">, Alias<dynamic_list>;
 def alias_entry_e : JoinedOrSeparate<["-"], "e">, Alias<entry>;
 def alias_export_dynamic_E: Flag<["-"], "E">, Alias<export_dynamic>;
 def alias_fini_fini : Joined<["-"], "fini=">, Alias<fini>;
Index: ELF/ScriptParser.h
===================================================================
--- ELF/ScriptParser.h
+++ ELF/ScriptParser.h
@@ -44,6 +44,8 @@
   bool Error = false;
 };
 
+bool matchGlobStr(StringRef S, StringRef T);
+
 } // namespace elf
 } // namespace lld
 
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -9,6 +9,7 @@
 
 #include "Writer.h"
 #include "Config.h"
+#include "DynamicList.h"
 #include "LinkerScript.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
@@ -841,6 +842,9 @@
     return false;
   if (Config->ExportDynamic || Config->Shared)
     return true;
+  if (Config->DynamicList)
+    if (DynList->isInDynamicList(B.getName()))
+      return true;
   return B.MustBeInDynSym;
 }
 
Index: test/ELF/dynamic-list.s
===================================================================
--- /dev/null
+++ test/ELF/dynamic-list.s
@@ -0,0 +1,104 @@
+## There is some bad quoting interaction between lit's internal shell, which is
+## implemented in Python, and the Cygwin implementations of the Unix utilities.
+## Avoid running these tests on Windows for now by requiring a real shell.
+
+# REQUIRES: shell
+
+# REQUIRES: x86
+
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %p/Inputs/shared.s -o %t2.o
+# RUN: ld.lld -shared %t2.o -soname shared -o %t2.so
+# RUN: llvm-mc -filetype=obj -triple=x86_64-unknown-linux %s -o %t
+
+## Check exporting only one symbol.
+# RUN: echo "{ foo1; };" > %t.list
+# RUN: ld.lld --dynamic-list %t.list %t %t2.so -o %t.exe
+# RUN: llvm-readobj -dyn-symbols %t.exe | FileCheck %s
+
+## And now using quoted strings (the output is the same since it does
+## use any wildcard character).
+# RUN: echo "{ \"foo1\"; };" > %t.list
+# RUN: ld.lld --dynamic-list %t.list %t %t2.so -o %t.exe
+# RUN: llvm-readobj -dyn-symbols %t.exe | FileCheck %s
+
+# CHECK:      DynamicSymbols [
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: @ (0)
+# CHECK-NEXT:     Value: 0x0
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Local
+# CHECK-NEXT:     Type: None
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: Undefined
+# CHECK-NEXT:   }
+# CHECK-NEXT:   Symbol {
+# CHECK-NEXT:     Name: foo1@ (1)
+# CHECK-NEXT:     Value: 0x11000
+# CHECK-NEXT:     Size: 0
+# CHECK-NEXT:     Binding: Global (0x1)
+# CHECK-NEXT:     Type: None (0x0)
+# CHECK-NEXT:     Other: 0
+# CHECK-NEXT:     Section: .text (0x4)
+# CHECK-NEXT:   }
+# CHECK-NEXT: ] 
+
+
+## Now export all the foo1, foo2, and foo31 symbols
+# RUN: echo "{ foo1; foo2; foo31; };" > %t.list
+# RUN: ld.lld --dynamic-list %t.list %t %t2.so -o %t.exe
+# RUN: llvm-readobj -dyn-symbols %t.exe | FileCheck -check-prefix=CHECK2 %s
+
+# CHECK2:      DynamicSymbols [
+# CHECK2-NEXT:   Symbol {
+# CHECK2-NEXT:     Name: @ (0)
+# CHECK2-NEXT:     Value: 0x0
+# CHECK2-NEXT:     Size: 0
+# CHECK2-NEXT:     Binding: Local
+# CHECK2-NEXT:     Type: None
+# CHECK2-NEXT:     Other: 0
+# CHECK2-NEXT:     Section: Undefined
+# CHECK2-NEXT:   }
+# CHECK2-NEXT:   Symbol {
+# CHECK2-NEXT:     Name: foo1@ (1)
+# CHECK2-NEXT:     Value: 0x11000
+# CHECK2-NEXT:     Size: 0
+# CHECK2-NEXT:     Binding: Global (0x1)
+# CHECK2-NEXT:     Type: None (0x0)
+# CHECK2-NEXT:     Other: 0
+# CHECK2-NEXT:     Section: .text (0x4)
+# CHECK2-NEXT:   }
+# CHECK2-NEXT:   Symbol {
+# CHECK2-NEXT:     Name: foo2@ (6)
+# CHECK2-NEXT:     Value: 0x11001
+# CHECK2-NEXT:     Size: 0
+# CHECK2-NEXT:     Binding: Global (0x1)
+# CHECK2-NEXT:     Type: None (0x0)
+# CHECK2-NEXT:     Other: 0
+# CHECK2-NEXT:     Section: .text (0x4)
+# CHECK2-NEXT:   }
+# CHECK2-NEXT:   Symbol {
+# CHECK2-NEXT:     Name: foo31@ (11)
+# CHECK2-NEXT:     Value: 0x11002
+# CHECK2-NEXT:     Size: 0
+# CHECK2-NEXT:     Binding: Global (0x1)
+# CHECK2-NEXT:     Type: None (0x0)
+# CHECK2-NEXT:     Other: 0
+# CHECK2-NEXT:     Section: .text (0x4)
+# CHECK2-NEXT:   }
+# CHECK2-NEXT: ] 
+
+.globl foo1
+foo1:
+  ret
+
+.globl foo2
+foo2:
+  ret
+
+.globl foo31
+foo31:
+  ret
+
+.globl _start
+_start:
+  retq
Index: test/ELF/invalid-dynamic-list.test
===================================================================
--- /dev/null
+++ test/ELF/invalid-dynamic-list.test
@@ -0,0 +1,37 @@
+## Different "echo" commands on Windows interpret quoted strings and
+## wildcards in similar but different way (On Windows, ARGV tokenization
+## and wildcard expansion are not done by the shell but by each command.)
+## Because of that reason, this test fails on some Windows environment.
+## We can't write quoted strings that are interpreted the same way
+## by all echo commands. So, we don't want to run this on Windows.
+
+# REQUIRES: shell
+
+# RUN: mkdir -p %t.dir
+
+# RUN: echo foobar > %t1
+# RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR1 %s
+# ERR1: line 1: { expected, but got foobar
+
+# RUN: echo "{ foobar;" > %t1
+# RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR2 %s
+# ERR2: line 1: unexpected EOF
+
+## Missing ';' before '}'
+# RUN: echo "{ foobar }" > %t1
+# RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR3 %s
+# ERR3: line 1: ; expected, but got }
+
+## Missing final ';'
+# RUN: echo "{ foobar; }" > %t1
+# RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR4 %s
+# ERR4: line 1: unexpected EOF
+
+## Missing \" in foobaar definition
+# RUN echo "{ \"foobar; };" > %t1
+# RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR5 %s
+# ERR5: line 1: unexpected EOF
+
+# RUN: echo "{ extern \"BOGUS\" { test }; };" > %t1
+# RUN: not ld.lld --dynamic-list %t1 2>&1 | FileCheck -check-prefix=ERR6 %s
+# ERR6: line 1: invalid language in extern definition (BOGUS)