Subzero: Fix symbol name mangling. Make flags global.

src/IceOperand.h

Index: src/IceOperand.h
diff --git a/src/IceOperand.h b/src/IceOperand.h
index f3a66fcba0c0ee488a802c6cb4258a97a7ef800d..3c2aec63d1ed1cb6d88f9c49e1fbc8f1ed823df8 100644
--- a/src/IceOperand.h
+++ b/src/IceOperand.h
@@ -120,9 +120,8 @@ class Constant : public Operand {
   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()); }
@@ -172,7 +171,7 @@ public:
         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
@@ -188,7 +187,7 @@ public:
     // 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) {
@@ -302,16 +301,14 @@ class RelocatableTuple {
 
 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;
 
@@ -319,7 +316,6 @@ public:
   const RelocOffsetArray OffsetExpr;
   const IceString Name;
   const IceString EmitString;
-  const bool SuppressMangling;
 };
 
 bool operator==(const RelocatableTuple &A, const RelocatableTuple &B);
@@ -334,9 +330,8 @@ class ConstantRelocatable : public Constant {
 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 {
@@ -350,7 +345,6 @@ public:
   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,
@@ -366,16 +360,14 @@ public:
 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
@@ -654,6 +646,8 @@ public:
   /// 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 IceString();
     return "lv$" + getName(Func);

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

Return "" is clearer, and should be the same.

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

Done - here and in IceInstARM32.cpp and IceInstMIPS32.cpp.

   }