[ELF] - Cleanup of scanVersionScript(): do not change local Demangled variable.

[grimar]

Summary

Previously if we had version script like

LIBSAMPLE_2.0 {

global:             
  extern "C++" { 
   bar;    
};

Demangled local variable was changed because std::map operator[] added
new element if there was no such key found.
That was confusing to see and unclean to have, patch fixes that.

[grimar]

• Do not make Demangled to be const (that reduces amount of changes). Since main aim of the patch is stop

modifying Demangled for correctness of futher patches, this change is itself enough.

[grimar]

D23794 has LGTM, it contains all changes from this patch. This one commited separatelly as r280066.

ELF/SymbolTable.cpp

static void setVersionId(SymbolBody *Body, StringRef VersionName,
   }
 
   Symbol *Sym = Body->symbol();
   if (Sym->VersionId != Config->DefaultSymbolVersion)
     warning("duplicate symbol " + Name + " in version script");
   Sym->VersionId = Version;
 }
 
+static bool hasExternCpp() {
+  for (VersionDefinition &V : Config->VersionDefinitions)
+    for (SymbolVersion Sym : V.Globals)
+      if (Sym.IsExternCpp)
+        return true;
+  return false;
+}
+
 template <class ELFT>
 std::map<std::string, SymbolBody *> SymbolTable<ELFT>::getDemangledSyms() {
   std::map<std::string, SymbolBody *> Result;
+  if (!hasExternCpp())
+    return Result;
   for (Symbol *Sym : SymVector) {
     SymbolBody *B = Sym->body();
     Result[demangle(B->getName())] = B;
   }
   return Result;
 }
 
-static bool hasExternCpp() {
-  for (VersionDefinition &V : Config->VersionDefinitions)
-    for (SymbolVersion Sym : V.Globals)
-      if (Sym.IsExternCpp)
-        return true;
-  return false;
+static SymbolBody *findDemangled(const std::map<std::string, SymbolBody *> &D,
+                                 StringRef Name) {
+  auto I = D.find(Name);
+  if (I != D.end())
+    return I->second;
+  return nullptr;
 }
 
 // This function processes the --version-script option by marking all global
 // symbols with the VersionScriptGlobal flag, which acts as a filter on the
 // dynamic symbol table.
 template <class ELFT> void SymbolTable<ELFT>::scanVersionScript() {
   // If version script does not contain versions declarations,
   // we just should mark global symbols.
template <class ELFT> void SymbolTable<ELFT>::scanVersionScript() {
   // Current rules are:
   // * If there is an exact match for the mangled name or we have extern C++
   //   exact match, then we use it.
   // * Otherwise, we look through the wildcard patterns. We look through the
   //   version tags in reverse order. We use the first match we find (the last
   //   matching version tag in the file).
   // Handle exact matches and build a map of demangled externs for
   // quick search during next step.
-  std::map<std::string, SymbolBody *> Demangled;
-  if (hasExternCpp())
-    Demangled = getDemangledSyms();
+  const std::map<std::string, SymbolBody *> Demangled = getDemangledSyms();
 
   for (VersionDefinition &V : Config->VersionDefinitions) {
     for (SymbolVersion Sym : V.Globals) {
       if (hasWildcard(Sym.Name))
         continue;
-      SymbolBody *B = Sym.IsExternCpp ? Demangled[Sym.Name] : find(Sym.Name);
-      setVersionId(B, V.Name, Sym.Name, V.Id);
+      StringRef N = Sym.Name;
+      SymbolBody *B = Sym.IsExternCpp ? findDemangled(Demangled, N) : find(N);
+      setVersionId(B, V.Name, N, V.Id);
     }
   }
 
   // Handle wildcards.
   for (size_t I = Config->VersionDefinitions.size() - 1; I != (size_t)-1; --I) {
     VersionDefinition &V = Config->VersionDefinitions[I];
     for (SymbolVersion &Sym : V.Globals)
       if (hasWildcard(Sym.Name))