[lld] Implement --dynamic-list

[zatrazz]

Summary

This patch implements the --dynamic-list option, which adds a list of
global symbol that either should not be bounded by default definition
when creating shared libraries, or add in dynamic symbol table in the
case of creating executables.

The patch modifies the ScriptParserBase class to use a list of Token
instead of StringRef, which contains information if the token is a
quoted or unquoted strings. It is used to use a faster search for
exact match symbol name.

The input file follow a similar format of linker script with some
simplifications (it does not have scope or node names). It leads
to a simplified parser define in DynamicList.{cpp,h}.

Symbol match is done by consulting two lists: first a StringSet
for exact match names (defined in quoted strings) and then each
glob definition (in the order of definition).

This patch depends on http://reviews.llvm.org/D18771

[emaste]

PR for --dynamic-list: http://llvm.org/pr26693

[ruiu]

ELF/DynamicList.cpp

34

I also don't like to support C++ mangled names now. There's a chance that we might want that later, but this patch is already too large, so please remove that feature.

ELF/ScriptParser.cpp

23–25

At least for now, I don't want to support glob patterns at all. Glob pattern can have huge performance impact on the linking speed. In most cases users pass a list of complete symbol names, so we should reject any patterns that contains glob metacharacters and do simple hash table lookup instead of glob pattern matching.

[zatrazz]

ELF/DynamicList.cpp

34

Although llvm itself does not use, I see no direct reason to not support. It does not interfere significantly with default matching rules (for glob patterns it will first check the language mangling and only applying the damangling in such case) if the script does not use it.

ELF/ScriptParser.cpp

23–25

As stated in http://llvm.org/pr26693 it is required for the sanitizers and at least from LLVm side it the main motivator for this patch. I think we can add an additional check on DynamicList to check if an dynamic list and fast return if it is not the case.

[ruiu]

ELF/DynamicList.cpp

34

Apparently this part of linker script was not designed with speed in mind, and I think the gnu linker went a bit too far on this front. How many users are really using this feature? Is this really what we want to have? We need to think carefully to decide whether we want to do the same thing as the gnu linker for mangled names.

ELF/ScriptParser.cpp

23–25

Do you need the glob pattern fro the sanitizer?

[pcc]

ELF/ScriptParser.cpp

23–25

FWIW, I think it should be pretty trivial to avoid using glob patterns in the sanitizer dynamic lists.

[zatrazz]

ELF/DynamicList.cpp

34

I would say it was designed for flexibility, since the idea is to define C++ (or any other supported language) symbols without tie to mangling reles for an specific ABI. It is possible to just use the mangled name instead, but since GNU ld supports multiples system with different mangling name schemes, this seems the solution to avoid such trap.

Anyway, I think performance-wise I it won't hurt default case, since demangling will just be used if 'extern...' is actually issued in the script. About the users, I am not sure since sanitizers itself does not make use of this (since it exports its API as C). However I expect that C++ libraries may use this instead of using mangling names.

ELF/ScriptParser.cpp

23–25

Yes, sanitizers uses dynamic list entries with '*' patterns.

[zatrazz]

This is an update of previous patch where I added an option
which makes lld check if --dynamic-list options is used before
trying to match a symbols. This should be faster for common
usage (building without the option).

[ruiu]

ELF/DynamicList.cpp

36

I don't want to support them until it is proved that we absolutely have to do that because it has huge performance impact if the option is enabled. The reason that "because gnu ld/gold do this" is too weak to justify. Even if it wouldn't hurt the default case, I wouldn't like to land a patch C++ name mangling and glob patterns right now, particularly as a part of the other large patch (I meant this patch which implements --dynamic-list.)

[jbulow]

To be compatible with GNU ld the syntax should be --dynamic-list=dynamic-list-file. The current patch does not accept the equal sign before the file name.

[zatrazz]

Updated patch based on previous comments:

• Different from ld/gold neither glob pattern nor mangled names (extern 'C++') are currently supported.

• Added alias for -dynamic-list= and --dynamic-list=

[zatrazz]

Ping, are the dynamic-list support ok for inclusion now? I am currently adjusting the compiler-rt dynamic list to be compatible with entries without glob chars.

ELF/CMakeLists.txt

 set(LLVM_TARGET_DEFINITIONS Options.td)
 tablegen(LLVM Options.inc -gen-opt-parser-defs)
 add_public_tablegen_target(ELFOptionsTableGen)
 
 add_lld_library(lldELF
   Driver.cpp
   DriverUtils.cpp
+  DynamicList.cpp
   Error.cpp
   ICF.cpp
   InputFiles.cpp
   InputSection.cpp
   LTO.cpp
   LinkerScript.cpp
   MarkLive.cpp
   OutputSections.cpp

ELF/Config.h

struct Configuration {
   llvm::StringRef Fini;
   llvm::StringRef Init;
   llvm::StringRef OutputFile;
   llvm::StringRef SoName;
   llvm::StringRef Sysroot;
   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;
   bool BsymbolicFunctions;
   bool BuildId;
   bool Demangle = true;
   bool DisableVerify;
   bool DiscardAll;

ELF/Driver.h

 public:
   void main(ArrayRef<const char *> Args);
   void addFile(StringRef Path);
   void addLibrary(StringRef Name);
 
 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);
 
   llvm::BumpPtrAllocator Alloc;
   bool WholeArchive = false;
   std::vector<std::unique_ptr<InputFile>> Files;
   std::vector<std::unique_ptr<MemoryBuffer>> OwningMBs;
 };

ELF/Driver.cpp

 #include "Config.h"
 #include "Error.h"
 #include "ICF.h"
 #include "InputFiles.h"
 #include "LinkerScript.h"
 #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"
 #include "llvm/Support/raw_ostream.h"
 #include <utility>
 
 using namespace llvm;
 using namespace llvm::ELF;
 using namespace llvm::object;
 
 using namespace lld;
 using namespace lld::elf;
 
 Configuration *elf::Config;
 LinkerDriver *elf::Driver;
 
 bool elf::link(ArrayRef<const char *> Args, raw_ostream &Error) {
   HasError = false;
   ErrorOS = &Error;
   Configuration C;
   LinkerDriver D;
   LinkerScript LS;
+  DynamicList DL;
   Config = &C;
   Driver = &D;
   Script = &LS;
+  DynList = &DL;
   Driver->main(Args);
   return !HasError;
 }
 
 static std::pair<ELFKind, uint16_t> parseEmulation(StringRef S) {
   if (S.endswith("_fbsd"))
     S = S.drop_back(5);
   if (S == "elf32btsmip")
case file_magic::elf_shared_object:
     }
     Files.push_back(createSharedFile(MBRef));
     return;
   default:
     Files.push_back(createObjectFile(MBRef));
   }
 }
 
+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);
   if (Path.empty())
     error("unable to find library -l" + Name);
   else
     addFile(Path);
 }
void LinkerDriver::readConfigs(opt::InputArgList &Args) {
 
   Config->DynamicLinker = getString(Args, OPT_dynamic_linker);
   Config->Entry = getString(Args, OPT_entry);
   Config->Fini = getString(Args, OPT_fini, "_fini");
   Config->Init = getString(Args, OPT_init, "_init");
   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);
   if (Config->LtoO > 3)
     error("invalid optimization level for LTO: " + getString(Args, OPT_lto_O));
 
   Config->ZExecStack = hasZOption(Args, "execstack");
   Config->ZNodelete = hasZOption(Args, "nodelete");

ELF/DynamicList.h

+//===- 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

ELF/DynamicList.cpp

+//===- 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;
+}

ELF/LinkerScript.cpp

int LinkerScript::compareSections(StringRef A, StringRef B) {
   auto E = SectionOrder.end();
   auto I = std::find(SectionOrder.begin(), E, A);
   auto J = std::find(SectionOrder.begin(), E, B);
   if (I == E || J == E)
     return 0;
   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 {
   typedef void (ScriptParser::*Handler)();
 
 public:
   ScriptParser(BumpPtrAllocator *A, StringRef S, bool B)
       : ScriptParserBase(S), Saver(*A), IsUnderSysroot(B) {}
void ScriptParser::readInclude() {
   StringRef Tok = next();
   auto MBOrErr = MemoryBuffer::getFile(Tok);
   if (!MBOrErr) {
     setError("cannot open " + Tok);
     return;
   }
   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());
 }
 
 void ScriptParser::readOutput() {
   // -o <file> takes predecence over OUTPUT(<file>).
   expect("(");
   StringRef Tok = next();
   if (Config->OutputFile.empty())

ELF/Options.td

def whole_archive : Flag<["--", "-"], "whole-archive">,
   HelpText<"Force load of all members in a static library">;
 
 def wrap : Separate<["--", "-"], "wrap">, MetaVarName<"<symbol>">,
   HelpText<"Use wrapper functions for symbol">;
 
 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>;
 def alias_Bstatic_dn: Flag<["-"], "dn">, Alias<Bstatic>;
 def alias_Bstatic_non_shared: Flag<["-"], "non_shared">, Alias<Bstatic>;
 def alias_Bstatic_static: Flag<["-"], "static">, Alias<Bstatic>;
 def alias_L__library_path : Joined<["--"], "library-path=">, Alias<L>;
 def alias_discard_all_x: Flag<["-"], "x">, Alias<discard_all>;

ELF/ScriptParser.h

 #define LLD_ELF_SCRIPT_PARSER_H
 
 #include "lld/Core/LLVM.h"
 #include "llvm/ADT/StringRef.h"
 
 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)
       : Input(S), Tokens(tokenize(S)) {}
   virtual ~ScriptParserBase() = default;
 
   virtual void run() = 0;
 
 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
 
 #endif

ELF/ScriptParser.cpp

 // list.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ScriptParser.h"
 #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)
     return;
   error("line " + Twine(getPos()) + ": " + Msg);
   Error = true;
 }
 
 // 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())
       return Ret;
 
     // Quoted token
     if (S.startswith("\"")) {
       size_t E = S.find("\"", 1);
       if (E == StringRef::npos) {
         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;
     }
 
     // Unquoted token
     size_t Pos = S.find_first_not_of(
         "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz"
         "0123456789_.$/\\~=+[]*?-:");
     // A character that cannot start a word (which is usually a
     // 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);
   }
 }
 
 // Skip leading whitespace characters or /**/-style comments.
 StringRef ScriptParserBase::skipSpace(StringRef S) {
   for (;;) {
     if (S.startswith("/*")) {
for (;;) {
     if (S.size() == Size)
       return S;
   }
 }
 
 // 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;
   if (atEOF()) {
     setError("unexpected EOF");
     return false;
   }
   if (Tokens[Pos] != Tok)
if (Tok != Expect)
     setError(Expect + " expected, but got " + Tok);
 }
 
 // Returns the current line number.
 size_t ScriptParserBase::getPos() {
   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;
 }

ELF/Writer.cpp

 //===- Writer.cpp ---------------------------------------------------------===//
 //
 //                             The LLVM Linker
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Writer.h"
 #include "Config.h"
 #include "LinkerScript.h"
+#include "DynamicList.h"
 #include "OutputSections.h"
 #include "SymbolTable.h"
 #include "Target.h"
 
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/StringMap.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Support/FileOutputBuffer.h"

 }
 
 static bool includeInDynsym(const SymbolBody &B) {
   uint8_t V = B.getVisibility();
   if (V != STV_DEFAULT && V != STV_PROTECTED)
     return false;
   if (Config->ExportDynamic || Config->Shared)
     return true;
+  if (DynList->isInDynamicList(B.getName()))
+    return true;
   return B.MustBeInDynSym;
 }
 
 // This class knows how to create an output section for a given
 // input section. Output section type is determined by various
 // factors, including input section's sh_flags, sh_type and
 // linker scripts.
 namespace {

test/ELF/dynamic-list.s

+## 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

test/ELF/invalid-dynamic-list.test

+## 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)