Subzero: Fix symbol name mangling. Make flags global.

src/IceGlobalContext.cpp

 //===- subzero/src/IceGlobalContext.cpp - Global context defs -------------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Defines aspects of the compilation that persist across multiple
 /// functions.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "IceGlobalContext.h"
 
 #include "IceCfg.h"
 #include "IceCfgNode.h"
 #include "IceClFlags.h"
+#include "IceClFlagsExtra.h"
 #include "IceDefs.h"
 #include "IceELFObjectWriter.h"
 #include "IceGlobalInits.h"
 #include "IceOperand.h"
 #include "IceTargetLowering.h"
 #include "IceTimerTree.h"
 #include "IceTypes.h"
 
 #ifdef __clang__
 #pragma clang diagnostic push
@@ skipping 212 matching lines @@
     Str << "|i16=" << Pool->Integers16.size();
     Str << "|i32=" << Pool->Integers32.size();
     Str << "|i64=" << Pool->Integers64.size();
     Str << "|Rel=" << Pool->Relocatables.size();
     Str << "|ExtRel=" << Pool->ExternRelocatables.size();
   }
   Str << "\n";
 }
 
 GlobalContext::GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
-                             ELFStreamer *ELFStr, const ClFlags &Flags)
+                             ELFStreamer *ELFStr)
     : ConstPool(new ConstantPool()), ErrorStatus(), StrDump(OsDump),
-      StrEmit(OsEmit), StrError(OsError), Flags(Flags), ObjectWriter(),
+      StrEmit(OsEmit), StrError(OsError), ObjectWriter(),
       OptQ(/*Sequential=*/Flags.isSequential(),
            /*MaxSize=*/Flags.getNumTranslationThreads()),
       // EmitQ is allowed unlimited size.
       EmitQ(/*Sequential=*/Flags.isSequential()),
       DataLowering(TargetDataLowering::createLowering(this)) {
   assert(OsDump && "OsDump is not defined for GlobalContext");
   assert(OsEmit && "OsEmit is not defined for GlobalContext");
   assert(OsError && "OsError is not defined for GlobalContext");
   // Make sure thread_local fields are properly initialized before any
   // accesses are made.  Do this here instead of at the start of
@@ skipping 20 matching lines @@
     ObjectWriter.reset(new ELFObjectWriter(*this, *ELFStr));
     break;
   case FT_Asm:
   case FT_Iasm:
     break;
   }
 
   // ProfileBlockInfoVarDecl is initialized here because it takes this as a
   // parameter -- we want to
   // ensure that at least this' member variables are initialized.
-  ProfileBlockInfoVarDecl = VariableDeclaration::create(this);
+  ProfileBlockInfoVarDecl = VariableDeclaration::createExternal(this);
   ProfileBlockInfoVarDecl->setAlignment(typeWidthInBytes(IceType_i64));
   ProfileBlockInfoVarDecl->setIsConstant(true);
 
   // Note: if you change this symbol, make sure to update
   // runtime/szrt_profiler.c as well.
   ProfileBlockInfoVarDecl->setName("__Sz_block_profile_info");
-  ProfileBlockInfoVarDecl->setSuppressMangling();
-  ProfileBlockInfoVarDecl->setLinkage(llvm::GlobalValue::ExternalLinkage);
 
   TargetLowering::staticInit(this);
 }
 
 void GlobalContext::translateFunctions() {
   while (std::unique_ptr<Cfg> Func = optQueueBlockingPop()) {
     // Install Func in TLS for Cfg-specific container allocators.
     CfgLocalAllocatorScope _(Func.get());
     // Reset per-function stats being accumulated in TLS.
     resetStats();
@@ skipping 96 matching lines @@
 void GlobalContext::lowerGlobals(const IceString &SectionSuffix) {
   TimerMarker T(TimerStack::TT_emitGlobalInitializers, this);
   const bool DumpGlobalVariables =
       BuildDefs::dump() &&
       (Flags.getVerbose() & IceV_GlobalInit & Cfg::defaultVerboseMask()) &&
       Flags.getVerboseFocusOn().empty();
   if (DumpGlobalVariables) {
     OstreamLocker L(this);
     Ostream &Stream = getStrDump();
     for (const Ice::VariableDeclaration *Global : Globals) {
-      Global->dump(this, Stream);
+      Global->dump(Stream);
     }
   }
   if (Flags.getDisableTranslation())
     return;
 
   addBlockInfoPtrs(ProfileBlockInfoVarDecl);
   // If we need to shuffle the layout of global variables, shuffle them now.
   if (getFlags().shouldReorderGlobalVariables()) {
     // Create a random number generator for global variable reordering.
     RandomNumberGenerator RNG(getFlags().getRandomSeed(),
@@ skipping 106 matching lines @@
         break;
       case EmitterWorkItem::WI_GlobalInits: {
         accumulateGlobals(Item->getGlobalInits());
       } break;
       case EmitterWorkItem::WI_Asm: {
         lowerGlobalsIfNoCodeHasBeenSeen();
         accumulateGlobals(Item->getGlobalInits());
 
         std::unique_ptr<Assembler> Asm = Item->getAsm();
         Asm->alignFunction();
-        IceString MangledName = mangleName(Asm->getFunctionName());
+        const IceString &Name = Asm->getFunctionName();
         switch (getFlags().getOutFileType()) {
         case FT_Elf:
-          getObjectWriter()->writeFunctionCode(MangledName, Asm->getInternal(),
+          getObjectWriter()->writeFunctionCode(Name, Asm->getInternal(),
                                                Asm.get());
           break;
         case FT_Iasm: {
           OstreamLocker L(this);
-          Cfg::emitTextHeader(MangledName, this, Asm.get());
+          Cfg::emitTextHeader(Name, this, Asm.get());
           Asm->emitIASBytes(this);
         } break;
         case FT_Asm:
           llvm::report_fatal_error("Unexpected FT_Asm");
           break;
         }
       } break;
       case EmitterWorkItem::WI_Cfg: {
         if (!BuildDefs::dump())
           llvm::report_fatal_error("WI_Cfg work item created inappropriately");
@@ skipping 23 matching lines @@
 // Scan a string for S[0-9A-Z]*_ patterns and replace them with
 // S<num>_ where <num> is the next base-36 value.  If a type name
 // legitimately contains that pattern, then the substitution will be
 // made in error and most likely the link will fail.  In this case,
 // the test classes can be rewritten not to use that pattern, which is
 // much simpler and more reliable than implementing a full demangling
 // parser.  Another substitution-in-error may occur if a type
 // identifier ends with the pattern S[0-9A-Z]*, because an immediately
 // following substitution string like "S1_" or "PS1_" may be combined
 // with the previous type.
-void GlobalContext::incrementSubstitutions(ManglerVector &OldName) const {
+void GlobalContext::incrementSubstitutions(ManglerVector &OldName) {
   const std::locale CLocale("C");
   // Provide extra space in case the length of <num> increases.
   ManglerVector NewName(OldName.size() * 2);
   size_t OldPos = 0;
   size_t NewPos = 0;
   size_t OldLen = OldName.size();
   for (; OldPos < OldLen; ++OldPos, ++NewPos) {
     if (OldName[OldPos] == '\0')
       break;
     if (OldName[OldPos] == 'S') {
@@ skipping 59 matching lines @@
     }
     NewName[NewPos] = OldName[OldPos];
   }
   assert(NewName[NewPos] == '\0');
   OldName = NewName;
 }
 
 // In this context, name mangling means to rewrite a symbol using a given
 // prefix. For a C++ symbol, nest the original symbol inside the "prefix"
 // namespace. For other symbols, just prepend the prefix.
-IceString GlobalContext::mangleName(const IceString &Name) const {
+IceString GlobalContext::mangleName(const IceString &Name) {
   // An already-nested name like foo::bar() gets pushed down one level, making
   // it equivalent to Prefix::foo::bar().
   //   _ZN3foo3barExyz ==> _ZN6Prefix3foo3barExyz
   // A non-nested but mangled name like bar() gets nested, making it equivalent
   // to Prefix::bar().
   //   _Z3barxyz ==> ZN6Prefix3barExyz
   // An unmangled, extern "C" style name, gets a simple prefix:
   //   bar ==> Prefixbar
   if (!BuildDefs::dump() || getFlags().getTestPrefix().empty())
     return Name;
@@ skipping 114 matching lines @@
   return getConstPool()->Floats.getOrAdd(this, ConstantFloat);
 }
 
 Constant *GlobalContext::getConstantDouble(double ConstantDouble) {
   return getConstPool()->Doubles.getOrAdd(this, ConstantDouble);
 }
 
 Constant *GlobalContext::getConstantSym(const RelocOffsetT Offset,
                                         const RelocOffsetArray &OffsetExpr,
                                         const IceString &Name,
-                                        const IceString &EmitString,
-                                        bool SuppressMangling) {
+                                        const IceString &EmitString) {
   return getConstPool()->Relocatables.getOrAdd(
-      this,
-      RelocatableTuple(Offset, OffsetExpr, Name, EmitString, SuppressMangling));
+      this, RelocatableTuple(Offset, OffsetExpr, Name, EmitString));
 }
 
 Constant *GlobalContext::getConstantSym(RelocOffsetT Offset,
-                                        const IceString &Name,
-                                        bool SuppressMangling) {
+                                        const IceString &Name) {
   constexpr char EmptyEmitString[] = "";
-  return getConstantSym(Offset, {}, Name, EmptyEmitString, SuppressMangling);
+  return getConstantSym(Offset, {}, Name, EmptyEmitString);
 }
 
 Constant *GlobalContext::getConstantExternSym(const IceString &Name) {
   constexpr RelocOffsetT Offset = 0;
-  constexpr bool SuppressMangling = true;
   return getConstPool()->ExternRelocatables.getOrAdd(
-      this, RelocatableTuple(Offset, {}, Name, SuppressMangling));
+      this, RelocatableTuple(Offset, {}, Name));
 }
 
 Constant *GlobalContext::getConstantUndef(Type Ty) {
   return getConstPool()->Undefs.getOrAdd(this, Ty);
 }
 
 // All locking is done by the getConstant*() target function.
 Constant *GlobalContext::getConstantZero(Type Ty) {
   switch (Ty) {
   case IceType_i1:
@@ skipping 86 matching lines @@
     // jump tables as pooled constants.
     RandomNumberGenerator RNG(getFlags().getRandomSeed(),
                               RPE_PooledConstantReordering);
     RandomShuffle(JumpTables.begin(), JumpTables.end(),
                   [&RNG](uint64_t N) { return (uint32_t)RNG.next(N); });
   }
   return JumpTables;
 }
 
 JumpTableData &
-GlobalContext::addJumpTable(IceString FuncName, SizeT Id,
+GlobalContext::addJumpTable(const IceString &FuncName, SizeT Id,
                             const JumpTableData::TargetList &TargetList) {
   auto JumpTableList = getJumpTableList();
   JumpTableList->emplace_back(FuncName, Id, TargetList);
   return JumpTableList->back();
 }
 
 TimerStackIdT GlobalContext::newTimerStackID(const IceString &Name) {
   if (!BuildDefs::dump())
     return 0;
   auto Timers = getTimers();
@@ skipping 72 matching lines @@
 
 void GlobalContext::dumpTimers(TimerStackIdT StackID, bool DumpCumulative) {
   if (!BuildDefs::dump())
     return;
   auto Timers = getTimers();
   assert(Timers->size() > StackID);
   OstreamLocker L(this);
   Timers->at(StackID).dump(getStrDump(), DumpCumulative);
 }
 
+ClFlags GlobalContext::Flags;
+ClFlagsExtra GlobalContext::ExtraFlags;

[John, 2016/03/06 22:39:38]

Do these have constructors?

[Jim Stichnoth, 2016/03/07 00:03:10]

Yes - and they get run as static initializers.  I guess that's not great, but
something I'd like to fix in a follow-on CL.

+
 void TimerMarker::push() {
   switch (StackID) {
   case GlobalContext::TSK_Default:
     Active = Ctx->getFlags().getSubzeroTimingEnabled();
     break;
   case GlobalContext::TSK_Funcs:
     Active = Ctx->getFlags().getTimeEachFunction();
     break;
   default:
     break;
   }
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 void TimerMarker::pushCfg(const Cfg *Func) {
   Ctx = Func->getContext();
   Active =
       Func->getFocusedTiming() || Ctx->getFlags().getSubzeroTimingEnabled();
   if (Active)
     Ctx->pushTimer(ID, StackID);
 }
 
 ICE_TLS_DEFINE_FIELD(GlobalContext::ThreadContext *, GlobalContext, TLS);
 
 } // end of namespace Ice