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
@@ -50,6 +50,7 @@
   std::string RPath;
   std::vector<llvm::StringRef> SearchPaths;
   std::vector<llvm::StringRef> Undefined;
+  std::vector<llvm::StringRef> DynamicList;
   bool AllowMultipleDefinition;
   bool AsNeeded = false;
   bool Bsymbolic;
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
@@ -16,6 +16,7 @@
 #include "SymbolTable.h"
 #include "Target.h"
 #include "Writer.h"
+#include "DynamicList.h"
 #include "lld/Driver/Driver.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/Support/TargetSelect.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);
+  StringRef DynamicListPath = getString(Args, OPT_dynamic_list);
+  if (!DynamicListPath.empty())
+    readDynamicList(DynamicListPath);
 
   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,49 @@
+//===- 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;
+  std::vector<std::pair<StringRef, GlobLanguage>> GlobSymbols;
+
+  llvm::BumpPtrAllocator Alloc;
+};
+
+extern DynamicList *DynList;
+
+} // namespace elf
+} // namespace lld
+
+#endif
Index: ELF/DynamicList.cpp
===================================================================
--- /dev/null
+++ ELF/DynamicList.cpp
@@ -0,0 +1,153 @@
+//===- 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 "ScriptParser.h"
+#include "Config.h"
+#include "Driver.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.
+  Token Entry = next();
+  if (Entry == "extern") {
+    StringRef Tok = peek();
+    // And 'extern' itself can be used a symbol name.
+    if (Tok == ";") {
+      DynList->ExactMatch.insert(Entry.Value);
+    } 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 {
+    if (Entry.Quoted)
+      DynList->ExactMatch.insert(Entry.Value);
+    else
+      DynList->GlobSymbols.push_back(std::make_pair(Entry.Value, Lang));
+  }
+}
+
+void DynamicListParser::run() {
+  while (!atEOF()) {
+    readGroup();
+  }
+}
+
+void DynamicList::read(MemoryBufferRef MB) {
+  DynamicListParser(MB.getBuffer()).run();
+}
+
+bool DynamicList::isInDynamicList(StringRef Symbol) {
+  // To avoid applying the matchStr algorithm on every entry, for quoted
+  // strings (which means exact match even with wildcards characteres) a
+  // StringSet map is created and it is consulted before matching the
+  // glob patterns.
+  if (ExactMatch.find(Symbol) != ExactMatch.end())
+    return true;
+
+  // For any other entry check each glob entry with language defined
+  // entries (for instance 'extern C++') being demangled first.
+  for (auto entry : GlobSymbols) {
+    if (entry.second == LANGUAGE_C) {
+      if (matchGlobStr(entry.first, Symbol))
+        return true;
+    } else if (entry.second == LANGUAGE_CXX) {
+      std::string NameToMatch = demangle(Symbol);
+      if (matchGlobStr(entry.first, NameToMatch))
+        return true;
+    }
+  }
+
+  return false;
+}
Index: ELF/LinkerScript.cpp
===================================================================
--- ELF/LinkerScript.cpp
+++ ELF/LinkerScript.cpp
@@ -74,32 +74,8 @@
   return I < J ? -1 : 1;
 }
 
-// Returns true if S matches T. S can contain glob meta-characters.
-// The asterisk ('*') matches zero or more characacters, and the question
-// mark ('?') matches one character.
-static bool matchStr(StringRef S, StringRef T) {
-  for (;;) {
-    if (S.empty())
-      return T.empty();
-    if (S[0] == '*') {
-      S = S.substr(1);
-      if (S.empty())
-        // Fast path. If a pattern is '*', it matches anything.
-        return true;
-      for (size_t I = 0, E = T.size(); I < E; ++I)
-        if (matchStr(S, T.substr(I)))
-          return true;
-      return false;
-    }
-    if (T.empty() || (S[0] != T[0] && S[0] != '?'))
-      return false;
-    S = S.substr(1);
-    T = T.substr(1);
-  }
-}
-
 template <class ELFT> bool SectionRule::match(InputSectionBase<ELFT> *S) {
-  return matchStr(SectionPattern, S->getSectionName());
+  return matchGlobStr(SectionPattern, S->getSectionName());
 }
 
 class elf::ScriptParser final : public elf::ScriptParserBase {
@@ -244,7 +220,7 @@
   }
   std::unique_ptr<MemoryBuffer> &MB = *MBOrErr;
   StringRef S = Saver.save(MB->getMemBufferRef().getBuffer());
-  std::vector<StringRef> V = tokenize(S);
+  std::vector<Token> V = tokenize(S);
   Tokens.insert(Tokens.begin() + Pos, V.begin(), V.end());
 }
 
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>;
Index: ELF/ScriptParser.h
===================================================================
--- ELF/ScriptParser.h
+++ ELF/ScriptParser.h
@@ -16,6 +16,17 @@
 namespace lld {
 namespace elf {
 
+class Token {
+public:
+  Token(StringRef V, bool Q = false) : Value(V), Quoted(Q) {}
+
+  bool operator==(StringRef Str) { return Value == Str; }
+  bool operator!=(StringRef Str) { return !operator==(Str); }
+
+  StringRef Value;
+  bool Quoted;
+};
+
 class ScriptParserBase {
 public:
   ScriptParserBase(StringRef S)
@@ -26,22 +37,26 @@
 
 protected:
   void setError(const Twine &Msg);
-  static std::vector<StringRef> tokenize(StringRef S);
+  static std::vector<Token> tokenize(StringRef S);
   static StringRef skipSpace(StringRef S);
   bool atEOF();
   StringRef next();
+  Token nextToken();
   StringRef peek();
+  Token peekToken();
   bool skip(StringRef Tok);
   void expect(StringRef Expect);
 
   size_t getPos();
 
   StringRef Input;
-  std::vector<StringRef> Tokens;
+  std::vector<Token> Tokens;
   size_t Pos = 0;
   bool Error = false;
 };
 
+bool matchGlobStr(StringRef S, StringRef T);
+
 } // namespace elf
 } // namespace lld
 
Index: ELF/ScriptParser.cpp
===================================================================
--- ELF/ScriptParser.cpp
+++ ELF/ScriptParser.cpp
@@ -16,9 +16,35 @@
 #include "Driver.h"
 
 using namespace llvm;
+using namespace llvm::object;
 using namespace lld;
 using namespace lld::elf;
 
+// Returns true if S matches T. S can contain glob meta-characters.
+// The asterisk ('*') matches zero or more characacters, and the question
+// mark ('?') matches one character.
+bool elf::matchGlobStr(StringRef S, StringRef T) {
+  for (;;) {
+    if (S.empty())
+      return T.empty();
+    if (S[0] == '*') {
+      S = S.substr(1);
+      if (S.empty())
+        // Fast path. If a pattern is '*', it matches anything.
+        return true;
+      for (size_t I = 0, E = T.size(); I < E; ++I)
+        if (matchGlobStr(S, T.substr(I)))
+          return true;
+      return false;
+    }
+    if (T.empty() || (S[0] != T[0] && S[0] != '?'))
+      return false;
+    S = S.substr(1);
+    T = T.substr(1);
+  }
+}
+
+
 // We don't want to record cascading errors. Keep only the first one.
 void ScriptParserBase::setError(const Twine &Msg) {
   if (Error)
@@ -28,8 +54,8 @@
 }
 
 // Split S into linker script tokens.
-std::vector<StringRef> ScriptParserBase::tokenize(StringRef S) {
-  std::vector<StringRef> Ret;
+std::vector<Token> ScriptParserBase::tokenize(StringRef S) {
+  std::vector<Token> Ret;
   for (;;) {
     S = skipSpace(S);
     if (S.empty())
@@ -42,7 +68,7 @@
         error("unclosed quote");
         return {};
       }
-      Ret.push_back(S.substr(1, E - 1));
+      Ret.push_back(Token(S.substr(1, E - 1), true));
       S = S.substr(E + 1);
       continue;
     }
@@ -55,7 +81,7 @@
     // punctuation) forms a single character token.
     if (Pos == 0)
       Pos = 1;
-    Ret.push_back(S.substr(0, Pos));
+    Ret.push_back(Token(S.substr(0, Pos), false));
     S = S.substr(Pos);
   }
 }
@@ -82,24 +108,32 @@
 // An erroneous token is handled as if it were the last token before EOF.
 bool ScriptParserBase::atEOF() { return Error || Tokens.size() == Pos; }
 
-StringRef ScriptParserBase::next() {
+Token ScriptParserBase::nextToken() {
   if (Error)
-    return "";
+    return Token("");
   if (atEOF()) {
     setError("unexpected EOF");
-    return "";
+    return Token("");
   }
   return Tokens[Pos++];
 }
 
-StringRef ScriptParserBase::peek() {
+StringRef ScriptParserBase::next() {
+  return nextToken().Value;
+}
+
+Token ScriptParserBase::peekToken() {
   StringRef Tok = next();
   if (Error)
-    return "";
+    return Token("");
   --Pos;
   return Tok;
 }
 
+StringRef ScriptParserBase::peek() {
+  return peekToken().Value;
+}
+
 bool ScriptParserBase::skip(StringRef Tok) {
   if (Error)
     return false;
@@ -126,6 +160,6 @@
   if (Pos == 0)
     return 1;
   const char *Begin = Input.data();
-  const char *Tok = Tokens[Pos - 1].data();
+  const char *Tok = Tokens[Pos - 1].Value.data();
   return StringRef(Begin, Tok - Begin).count('\n') + 1;
 }
Index: ELF/Writer.cpp
===================================================================
--- ELF/Writer.cpp
+++ ELF/Writer.cpp
@@ -10,6 +10,7 @@
 #include "Writer.h"
 #include "Config.h"
 #include "LinkerScript.h"
+#include "DynamicList.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
 #include "Target.h"
@@ -850,6 +851,8 @@
     return false;
   if (Config->ExportDynamic || Config->Shared)
     return true;
+  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,136 @@
+## 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 "{ foo*; };" > %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: ] 
+
+## Now export all the cppfoo using the demangle name match
+# RUN: echo "{ extern \"C++\" { \"cppfoo()\" }; };" > %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=CHECK3 %s
+
+# CHECK3:      DynamicSymbols [
+# CHECK3-NEXT:   Symbol {
+# CHECK3-NEXT:     Name: @ (0)
+# CHECK3-NEXT:     Value: 0x0
+# CHECK3-NEXT:     Size: 0
+# CHECK3-NEXT:     Binding: Local
+# CHECK3-NEXT:     Type: None
+# CHECK3-NEXT:     Other: 0
+# CHECK3-NEXT:     Section: Undefined
+# CHECK3-NEXT:   }
+# CHECK3-NEXT:   Symbol {
+# CHECK3-NEXT:     Name: _Z6cppfoov@ (1)
+# CHECK3-NEXT:     Value: 0x11003
+# CHECK3-NEXT:     Size: 0
+# CHECK3-NEXT:     Binding: Global (0x1)
+# CHECK3-NEXT:     Type: None (0x0)
+# CHECK3-NEXT:     Other: 0
+# CHECK3-NEXT:     Section: .text (0x4)
+# CHECK3-NEXT:   }
+# CHECK3-NEXT: ] 
+
+.globl foo1
+foo1:
+  ret
+
+.globl foo2
+foo2:
+  ret
+
+.globl foo31
+foo31:
+  ret
+
+## int cppfoo (void)
+.globl _Z6cppfoov
+_Z6cppfoov:
+  xorl %eax, %eax
+  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)