Subzero: Fix symbol name mangling. Make flags global.

src/IceOperand.h

 //===- subzero/src/IceOperand.h - High-level operands -----------*- C++ -*-===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 102 matching lines @@
 }
 
 /// Constant is the abstract base class for constants. All constants are
 /// allocated from a global arena and are pooled.
 class Constant : public Operand {
   Constant() = delete;
   Constant(const Constant &) = delete;
   Constant &operator=(const Constant &) = delete;
 
 public:
-  virtual void emitPoolLabel(Ostream &Str, const GlobalContext *Ctx) const {
+  virtual void emitPoolLabel(Ostream &Str) const {
     (void)Str;
-    (void)Ctx;
     llvm::report_fatal_error("emitPoolLabel not defined for type");
   };
   void emit(const Cfg *Func) const override { emit(Func->getTarget()); }
   virtual void emit(TargetLowering *Target) const = 0;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind >= kConst_Base && Kind <= kConst_Max;
   }
 
@@ skipping 29 matching lines @@
 
 public:
   using PrimType = T;
 
   static ConstantPrimitive *create(GlobalContext *Ctx, Type Ty,
                                    PrimType Value) {
     return new (Ctx->allocate<ConstantPrimitive>())
         ConstantPrimitive(Ty, Value);
   }
   PrimType getValue() const { return Value; }
-  void emitPoolLabel(Ostream &Str, const GlobalContext *Ctx) const final {
+  void emitPoolLabel(Ostream &Str) const final {
     Str << ".L$" << getType() << "$";
     // Print hex characters byte by byte, starting from the most significant
     // byte.  NOTE: This ordering assumes Subzero runs on a little-endian
     // platform.  That means the possibility of different label names depending
     // on the endian-ness of the platform where Subzero runs.
     for (unsigned i = 0; i < sizeof(Value); ++i) {
       constexpr unsigned HexWidthChars = 2;
       unsigned Offset = sizeof(Value) - 1 - i;
       Str << llvm::format_hex_no_prefix(
           *(Offset + (const unsigned char *)&Value), HexWidthChars);
     }
     // For a floating-point value in DecorateAsm mode, also append the value in
     // human-readable sprintf form, changing '+' to 'p' and '-' to 'm' to
     // maintain valid asm labels.
     if (std::is_floating_point<PrimType>::value && !BuildDefs::minimal() &&
-        Ctx->getFlags().getDecorateAsm()) {
+        GlobalContext::getFlags().getDecorateAsm()) {
       char Buf[30];
       snprintf(Buf, llvm::array_lengthof(Buf), "$%g", (double)Value);
       for (unsigned i = 0; i < llvm::array_lengthof(Buf) && Buf[i]; ++i) {
         if (Buf[i] == '-')
           Buf[i] = 'm';
         else if (Buf[i] == '+')
           Buf[i] = 'p';
       }
       Str << Buf;
     }
@@ skipping 93 matching lines @@
 
 /// RelocatableTuple bundles the parameters that are used to construct an
 /// ConstantRelocatable. It is done this way so that ConstantRelocatable can fit
 /// into the global constant pool template mechanism.
 class RelocatableTuple {
   RelocatableTuple() = delete;
   RelocatableTuple &operator=(const RelocatableTuple &) = delete;
 
 public:
   RelocatableTuple(const RelocOffsetT Offset,
-                   const RelocOffsetArray &OffsetExpr, const IceString &Name,
-                   bool SuppressMangling)
-      : Offset(Offset), OffsetExpr(OffsetExpr), Name(Name),
-        SuppressMangling(SuppressMangling) {}
+                   const RelocOffsetArray &OffsetExpr, const IceString &Name)
+      : Offset(Offset), OffsetExpr(OffsetExpr), Name(Name) {}
 
   RelocatableTuple(const RelocOffsetT Offset,
                    const RelocOffsetArray &OffsetExpr, const IceString &Name,
-                   const IceString &EmitString, bool SuppressMangling)
+                   const IceString &EmitString)
       : Offset(Offset), OffsetExpr(OffsetExpr), Name(Name),
-        EmitString(EmitString), SuppressMangling(SuppressMangling) {}
+        EmitString(EmitString) {}
 
   RelocatableTuple(const RelocatableTuple &) = default;
 
   const RelocOffsetT Offset;
   const RelocOffsetArray OffsetExpr;
   const IceString Name;
   const IceString EmitString;
-  const bool SuppressMangling;
 };
 
 bool operator==(const RelocatableTuple &A, const RelocatableTuple &B);
 
 /// ConstantRelocatable represents a symbolic constant combined with a fixed
 /// offset.
 class ConstantRelocatable : public Constant {
   ConstantRelocatable() = delete;
   ConstantRelocatable(const ConstantRelocatable &) = delete;
   ConstantRelocatable &operator=(const ConstantRelocatable &) = delete;
 
 public:
   static ConstantRelocatable *create(GlobalContext *Ctx, Type Ty,
                                      const RelocatableTuple &Tuple) {
-    return new (Ctx->allocate<ConstantRelocatable>())
-        ConstantRelocatable(Ty, Tuple.Offset, Tuple.OffsetExpr, Tuple.Name,
-                            Tuple.EmitString, Tuple.SuppressMangling);
+    return new (Ctx->allocate<ConstantRelocatable>()) ConstantRelocatable(
+        Ty, Tuple.Offset, Tuple.OffsetExpr, Tuple.Name, Tuple.EmitString);
   }
 
   RelocOffsetT getOffset() const {
     RelocOffsetT Ret = Offset;
     for (const auto *const OffsetReloc : OffsetExpr) {
       Ret += OffsetReloc->getOffset();
     }
     return Ret;
   }
 
   const IceString &getEmitString() const { return EmitString; }
 
   const IceString &getName() const { return Name; }
-  bool getSuppressMangling() const { return SuppressMangling; }
   using Constant::emit;
   void emit(TargetLowering *Target) const final;
   void emitWithoutPrefix(const TargetLowering *Target,
                          const char *Suffix = "") const;
   using Constant::dump;
   void dump(const Cfg *Func, Ostream &Str) const override;
 
   static bool classof(const Operand *Operand) {
     OperandKind Kind = Operand->getKind();
     return Kind == kConstRelocatable;
   }
 
 private:
   ConstantRelocatable(Type Ty, const RelocOffsetT Offset,
                       const RelocOffsetArray &OffsetExpr, const IceString &Name,
-                      const IceString &EmitString, bool SuppressMangling)
+                      const IceString &EmitString)
       : Constant(kConstRelocatable, Ty), Offset(Offset), OffsetExpr(OffsetExpr),
-        Name(Name), EmitString(EmitString), SuppressMangling(SuppressMangling) {
-  }
+        Name(Name), EmitString(EmitString) {}
 
   const RelocOffsetT Offset;         /// fixed, known offset to add
   const RelocOffsetArray OffsetExpr; /// fixed, unknown offset to add
   const IceString Name;              /// optional for debug/dump
   const IceString EmitString;        /// optional for textual emission
-  const bool SuppressMangling;
 };
 
 /// ConstantUndef represents an unspecified bit pattern. Although it is legal to
 /// lower ConstantUndef to any value, backends should try to make code
 /// generation deterministic by lowering ConstantUndefs to 0.
 class ConstantUndef : public Constant {
   ConstantUndef() = delete;
   ConstantUndef(const ConstantUndef &) = delete;
   ConstantUndef &operator=(const ConstantUndef &) = delete;
 
@@ skipping 258 matching lines @@
   void setIsImplicitArg(bool Val = true) { IsImplicitArgument = Val; }
 
   void setIgnoreLiveness() { IgnoreLiveness = true; }
   bool getIgnoreLiveness() const { return IgnoreLiveness; }
 
   int32_t getStackOffset() const { return StackOffset; }
   void setStackOffset(int32_t Offset) { StackOffset = Offset; }
   /// Returns the variable's stack offset in symbolic form, to improve
   /// readability in DecorateAsm mode.
   IceString getSymbolicStackOffset(const Cfg *Func) const {
+    if (!BuildDefs::dump())
+      return "";
     return "lv$" + getName(Func);
   }
 
   bool hasReg() const { return getRegNum().hasValue(); }
   RegNumT getRegNum() const { return RegNum; }
   void setRegNum(RegNumT NewRegNum) {
     // Regnum shouldn't be set more than once.
     assert(!hasReg() || RegNum == NewRegNum);
     RegNum = NewRegNum;
   }
@@ skipping 266 matching lines @@
 private:
   const Cfg *Func;
   MetadataKind Kind;
   CfgVector<VariableTracking> Metadata;
   const static InstDefList NoDefinitions;
 };
 
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICEOPERAND_H