Subzero: Fix symbol name mangling. Make flags global.

src/IceGlobalContext.h

 //===- subzero/src/IceGlobalContext.h - Global context defs -----*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 137 matching lines @@
     ThreadContext() = default;
     CodeStats StatsFunction;
     CodeStats StatsCumulative;
     TimerList Timers;
   };
 
 public:
   /// The dump stream is a log stream while emit is the stream code
   /// is emitted to. The error stream is strictly for logging errors.
   GlobalContext(Ostream *OsDump, Ostream *OsEmit, Ostream *OsError,
-                ELFStreamer *ELFStreamer, const ClFlags &Flags);
+                ELFStreamer *ELFStreamer);
   ~GlobalContext();
 
   ///
   /// The dump, error, and emit streams need to be used by only one
   /// thread at a time.  This is done by exclusively reserving the
   /// streams via lockStr() and unlockStr().  The OstreamLocker class
   /// can be used to conveniently manage this.
   ///
   /// The model is that a thread grabs the stream lock, then does an
   /// arbitrary amount of work during which far-away callees may grab
   /// the stream and do something with it, and finally the thread
   /// releases the stream lock.  This allows large chunks of output to
   /// be dumped or emitted without risking interleaving from multiple
   /// threads.
   void lockStr() { StrLock.lock(); }
   void unlockStr() { StrLock.unlock(); }
   Ostream &getStrDump() { return *StrDump; }
   Ostream &getStrError() { return *StrError; }
   Ostream &getStrEmit() { return *StrEmit; }
   void setStrEmit(Ostream &NewStrEmit) { StrEmit = &NewStrEmit; }
 
   LockedPtr<ErrorCode> getErrorStatus() {
     return LockedPtr<ErrorCode>(&ErrorStatus, &ErrorStatusLock);
   }
 
-  /// When emitting assembly, we allow a string to be prepended to
-  /// names of translated functions.  This makes it easier to create an
-  /// execution test against a reference translator like llc, with both
-  /// translators using the same bitcode as input.
-  IceString mangleName(const IceString &Name) const;
-
   /// \name Manage Constants.
   /// @{
   // getConstant*() functions are not const because they might add something to
   // the constant pool.
   Constant *getConstantInt(Type Ty, int64_t Value);
   Constant *getConstantInt1(int8_t ConstantInt1);
   Constant *getConstantInt8(int8_t ConstantInt8);
   Constant *getConstantInt16(int16_t ConstantInt16);
   Constant *getConstantInt32(int32_t ConstantInt32);
   Constant *getConstantInt64(int64_t ConstantInt64);
   Constant *getConstantFloat(float Value);
   Constant *getConstantDouble(double Value);
   /// Returns a symbolic constant.
   Constant *getConstantSym(const RelocOffsetT Offset,
                            const RelocOffsetArray &OffsetExpr,
-                           const IceString &Name, const IceString &EmitString,
-                           bool SuppressMangling);
-  Constant *getConstantSym(RelocOffsetT Offset, const IceString &Name,
-                           bool SuppressMangling);
+                           const IceString &Name, const IceString &EmitString);
+  Constant *getConstantSym(RelocOffsetT Offset, const IceString &Name);
   Constant *getConstantExternSym(const IceString &Name);
   /// Returns an undef.
   Constant *getConstantUndef(Type Ty);
   /// Returns a zero value.
   Constant *getConstantZero(Type Ty);
   /// getConstantPool() returns a copy of the constant pool for constants of a
   /// given type.
   ConstantList getConstantPool(Type Ty);
   /// Returns a copy of the list of external symbols.
   ConstantList getConstantExternSyms();
   /// @}
 
   /// Return a locked pointer to the registered jump tables.
   JumpTableDataList getJumpTables();
   /// Create a new jump table entry and return a reference to it.
-  JumpTableData &addJumpTable(IceString FuncName, SizeT Id,
+  JumpTableData &addJumpTable(const IceString &FuncName, SizeT Id,
                               const JumpTableData::TargetList &TargetList);
 
-  const ClFlags &getFlags() const { return Flags; }
+  static const ClFlags &getFlags() { return Flags; }
 
   /// Allocate data of type T using the global allocator. We allow entities
   /// allocated from this global allocator to be either trivially or
   /// non-trivially destructible. We optimize the case when T is trivially
   /// destructible by not registering a destructor. Destructors will be invoked
   /// during GlobalContext destruction in the reverse object creation order.
   template <typename T>
   typename std::enable_if<std::is_trivially_destructible<T>::value, T>::type *
   allocate() {
     return getAllocator()->Allocate<T>();
@@ skipping 193 matching lines @@
   /// Utility function to match a symbol name against a match string. This is
   /// used in a few cases where we want to take some action on a particular
   /// function or symbol based on a command-line argument, such as changing the
   /// verbose level for a particular function. An empty Match argument means
   /// match everything. Returns true if there is a match.
   static bool matchSymbolName(const IceString &SymbolName,
                               const IceString &Match) {
     return Match.empty() || Match == SymbolName;
   }
 
+  static ClFlags Flags;
+  static ClFlagsExtra ExtraFlags;
+
 private:
   // Try to ensure mutexes are allocated on separate cache lines.
 
   // Destructors collaborate with Allocator
   ICE_CACHELINE_BOUNDARY;
   // Managed by getAllocator()
   GlobalLockType AllocLock;
   ArenaAllocator Allocator;
 
   ICE_CACHELINE_BOUNDARY;
@@ skipping 31 matching lines @@
   /// StrLock is a global lock on the dump and emit output streams.
   using StrLockType = std::mutex;
   StrLockType StrLock;
   Ostream *StrDump;  /// Stream for dumping / diagnostics
   Ostream *StrEmit;  /// Stream for code emission
   Ostream *StrError; /// Stream for logging errors.
 
   ICE_CACHELINE_BOUNDARY;
 
   Intrinsics IntrinsicsInfo;
-  const ClFlags &Flags;
   // TODO(jpp): move to EmitterContext.
   std::unique_ptr<ELFObjectWriter> ObjectWriter;
   BoundedProducerConsumerQueue<Cfg> OptQ;
   BoundedProducerConsumerQueue<EmitterWorkItem> EmitQ;
   // DataLowering is only ever used by a single thread at a time (either in
   // emitItems(), or in IceCompiler::run before the compilation is over.)
   // TODO(jpp): move to EmitterContext.
   std::unique_ptr<TargetDataLowering> DataLowering;
   /// If !HasEmittedCode, SubZero will accumulate all Globals (which are "true"
   /// program global variables) until the first code WorkItem is seen.
@@ skipping 38 matching lines @@
 
   void addBlockInfoPtrs(VariableDeclaration *ProfileBlockInfo);
 
   llvm::SmallVector<ThreadContext *, 128> AllThreadContexts;
   llvm::SmallVector<std::thread, 128> TranslationThreads;
   llvm::SmallVector<std::thread, 128> EmitterThreads;
   // Each thread has its own TLS pointer which is also held in
   // AllThreadContexts.
   ICE_TLS_DECLARE_FIELD(ThreadContext *, TLS);
 
-  // Private helpers for mangleName()
-  using ManglerVector = llvm::SmallVector<char, 32>;
-  void incrementSubstitutions(ManglerVector &OldName) const;
-
 public:
   static void TlsInit() { ICE_TLS_INIT_FIELD(TLS); }
 };
 
 /// Helper class to push and pop a timer marker. The constructor pushes a
 /// marker, and the destructor pops it. This is for convenient timing of regions
 /// of code.
 class TimerMarker {
   TimerMarker() = delete;
   TimerMarker(const TimerMarker &) = delete;
@@ skipping 39 matching lines @@
   explicit OstreamLocker(GlobalContext *Ctx) : Ctx(Ctx) { Ctx->lockStr(); }
   ~OstreamLocker() { Ctx->unlockStr(); }
 
 private:
   GlobalContext *const Ctx;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEGLOBALCONTEXT_H