Fix a use-after-free in `llvm-config`.

[DiamondLovesYou]

Summary

This could happen if GetComponentNames is true, because Name from
VisitComponent would reference a stack instance of std::string in
ComputeLibsForComponents.

[beanz]

LGTM.

llvm/trunk/tools/llvm-config/llvm-config.cpp

 ///
 /// \param Name - The component to traverse.
 /// \param ComponentMap - A prebuilt map of component names to descriptors.
 /// \param VisitedComponents [in] [out] - The set of already visited components.
 /// \param RequiredLibs [out] - The ordered list of required
 /// libraries.
 /// \param GetComponentNames - Get the component names instead of the
 /// library name.
-static void VisitComponent(StringRef Name,
+static void VisitComponent(const std::string& Name,
                            const StringMap<AvailableComponent*> &ComponentMap,
                            std::set<AvailableComponent*> &VisitedComponents,
-                           std::vector<StringRef> &RequiredLibs,
+                           std::vector<std::string> &RequiredLibs,
                            bool IncludeNonInstalled, bool GetComponentNames,
                            const std::string *ActiveLibDir, bool *HasMissing) {
   // Lookup the component.
   AvailableComponent *AC = ComponentMap.lookup(Name);
   assert(AC && "Invalid component name!");
 
   // Add to the visited table.
   if (!VisitedComponents.insert(AC).second) {

 /// \brief Compute the list of required libraries for a given list of
 /// components, in an order suitable for passing to a linker (that is, libraries
 /// appear prior to their dependencies).
 ///
 /// \param Components - The names of the components to find libraries for.
 /// \param IncludeNonInstalled - Whether non-installed components should be
 /// reported.
 /// \param GetComponentNames - True if one would prefer the component names.
-static std::vector<StringRef>
+static std::vector<std::string>
 ComputeLibsForComponents(const std::vector<StringRef> &Components,
                          bool IncludeNonInstalled, bool GetComponentNames,
                          const std::string *ActiveLibDir, bool *HasMissing) {
-  std::vector<StringRef> RequiredLibs;
+  std::vector<std::string> RequiredLibs;
   std::set<AvailableComponent *> VisitedComponents;
 
   // Build a map of component names to information.
   StringMap<AvailableComponent*> ComponentMap;
   for (unsigned i = 0; i != array_lengthof(AvailableComponents); ++i) {
     AvailableComponent *AC = &AvailableComponents[i];
     ComponentMap[AC->Name] = AC;
   }
std::string GetExecutablePath(const char *Argv0) {
   // This just needs to be some symbol in the binary; C++ doesn't
   // allow taking the address of ::main however.
   void *P = (void*) (intptr_t) GetExecutablePath;
   return llvm::sys::fs::getMainExecutable(Argv0, P);
 }
 
 /// \brief Expand the semi-colon delimited LLVM_DYLIB_COMPONENTS into
 /// the full list of components.
-std::vector<StringRef> GetAllDyLibComponents(const bool IsInDevelopmentTree,
+std::vector<std::string> GetAllDyLibComponents(const bool IsInDevelopmentTree,
                                                const bool GetComponentNames) {
   std::vector<StringRef> DyLibComponents;
 
   StringRef DyLibComponentsStr(LLVM_DYLIB_COMPONENTS);
   size_t Offset = 0;
   while (true) {
     const size_t NextOffset = DyLibComponentsStr.find(';', Offset);
     DyLibComponents.push_back(DyLibComponentsStr.substr(Offset, NextOffset));
     if (NextOffset == std::string::npos) {
if (Arg.startswith("-")) {
       } else if (Arg == "--libnames") {
         PrintLibNames = true;
       } else if (Arg == "--libfiles") {
         PrintLibFiles = true;
       } else if (Arg == "--components") {
         /// If there are missing static archives and a dylib was
         /// built, print LLVM_DYLIB_COMPONENTS instead of everything
         /// in the manifest.
-        std::vector<StringRef> Components;
+        std::vector<std::string> Components;
         for (unsigned j = 0; j != array_lengthof(AvailableComponents); ++j) {
           // Only include non-installed components when in a development tree.
           if (!AvailableComponents[j].IsInstalled && !IsInDevelopmentTree)
             continue;
 
           Components.push_back(AvailableComponents[j].Name);
           if (AvailableComponents[j].Library && !IsInDevelopmentTree) {
             if (DyLibExists &&
if (PrintLibs || PrintLibNames || PrintLibFiles || PrintSystemLibs ||
     }
 
     // If no components were specified, default to "all".
     if (Components.empty())
       Components.push_back("all");
 
     // Construct the list of all the required libraries.
     bool HasMissing = false;
-    std::vector<StringRef> RequiredLibs =
+    std::vector<std::string> RequiredLibs =
         ComputeLibsForComponents(Components,
                                  /*IncludeNonInstalled=*/IsInDevelopmentTree,
                                  false, &ActiveLibDir, &HasMissing);
 
     if (PrintSharedMode) {
       std::unordered_set<std::string> FullDyLibComponents;
-      std::vector<StringRef> DyLibComponents =
+      std::vector<std::string> DyLibComponents =
           GetAllDyLibComponents(IsInDevelopmentTree, false);
 
       for (auto &Component : DyLibComponents) {
         FullDyLibComponents.insert(Component);
       }
       DyLibComponents.clear();
 
       for (auto &Lib : RequiredLibs) {
if (PrintLibs || PrintLibNames || PrintLibFiles) {
           }
         }
       };
 
       if (HasMissing && DyLibExists) {
         PrintForLib(DyLibName, true);
       } else {
         for (unsigned i = 0, e = RequiredLibs.size(); i != e; ++i) {
-          StringRef Lib = RequiredLibs[i];
+          auto Lib = RequiredLibs[i];
           if (i)
             OS << ' ';
 
           PrintForLib(Lib, false);
         }
       }
       OS << '\n';
     }