Subzero: Fix symbol name mangling. Make flags global.

src/IceTargetLoweringX86BaseImpl.h

 //===- subzero/src/IceTargetLoweringX86BaseImpl.h - x86 lowering -*- C++ -*-==//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 1325 matching lines @@
   }
   if (auto *Mem = llvm::dyn_cast<X86OperandMem>(Operand)) {
     Constant *Offset = Mem->getOffset();
     if (Offset == nullptr) {
       Offset = Ctx->getConstantInt32(4);
     } else if (auto *IntOffset = llvm::dyn_cast<ConstantInteger32>(Offset)) {
       Offset = Ctx->getConstantInt32(4 + IntOffset->getValue());
     } else if (auto *SymOffset = llvm::dyn_cast<ConstantRelocatable>(Offset)) {
       assert(!Utils::WouldOverflowAdd(SymOffset->getOffset(), 4));
       Offset =
-          Ctx->getConstantSym(4 + SymOffset->getOffset(), SymOffset->getName(),
-                              SymOffset->getSuppressMangling());
+          Ctx->getConstantSym(4 + SymOffset->getOffset(), SymOffset->getName());
     }
     auto *MemOperand = X86OperandMem::create(
         Func, IceType_i32, Mem->getBase(), Offset, Mem->getIndex(),
         Mem->getShift(), Mem->getSegmentRegister(), Mem->getIsRebased());
     // Test if the Offset is an eligible i32 constants for randomization and
     // pooling. Blind/pool it if it is. Otherwise return as oridinary mem
     // operand.
     return legalize(MemOperand);
   }
   llvm_unreachable("Unsupported operand type");
@@ skipping 4041 matching lines @@
     NewAddr.Index = nullptr;
     NewAddr.Shift = 0;
   }
 
   Constant *OffsetOp = nullptr;
   if (NewAddr.Relocatable == nullptr) {
     OffsetOp = Ctx->getConstantInt32(NewAddr.Offset);
   } else {
     OffsetOp =
         Ctx->getConstantSym(NewAddr.Relocatable->getOffset() + NewAddr.Offset,
-                            NewAddr.Relocatable->getName(),
-                            NewAddr.Relocatable->getSuppressMangling());
+                            NewAddr.Relocatable->getName());
   }
   // Vanilla ICE load instructions should not use the segment registers, and
   // computeAddressOpt only works at the level of Variables and Constants, not
   // other X86OperandMem, so there should be no mention of segment
   // registers there either.
   static constexpr auto SegmentReg =
       X86OperandMem::SegmentRegisters::DefaultSegment;
 
   return X86OperandMem::create(Func, MemType, NewAddr.Base, OffsetOp,
                                NewAddr.Index, NewAddr.Shift, SegmentReg);
@@ skipping 436 matching lines @@
         assert(Traits::Is64Bit);
         _mov(Index, RangeIndex); // trunc
       } else {
         _movzx(Index, RangeIndex);
       }
     } else {
       Index = legalizeToReg(RangeIndex);
     }
 
     constexpr RelocOffsetT RelocOffset = 0;
-    constexpr bool SuppressMangling = true;
-    IceString MangledName = Ctx->mangleName(Func->getFunctionName());
+    const IceString &FunctionName = Func->getFunctionName();
     constexpr Variable *NoBase = nullptr;
     Constant *Offset = Ctx->getConstantSym(
-        RelocOffset, InstJumpTable::makeName(MangledName, JumpTable->getId()),
-        SuppressMangling);
+        RelocOffset, InstJumpTable::makeName(FunctionName, JumpTable->getId()));
     uint16_t Shift = typeWidthInBytesLog2(PointerType);
     constexpr auto Segment = X86OperandMem::SegmentRegisters::DefaultSegment;
 
     Variable *Target = nullptr;
     if (Traits::Is64Bit && NeedSandboxing) {
       assert(Index != nullptr && Index->getType() == IceType_i32);
     }
     auto *TargetInMemory = X86OperandMem::create(Func, PointerType, NoBase,
                                                  Offset, Index, Shift, Segment);
     _mov(Target, TargetInMemory);
@@ skipping 921 matching lines @@
       if (auto *ConstFloat = llvm::dyn_cast<ConstantFloat>(Const)) {
         if (Utils::isPositiveZero(ConstFloat->getValue()))
           return makeZeroedRegister(Ty, RegNum);
       } else if (auto *ConstDouble = llvm::dyn_cast<ConstantDouble>(Const)) {
         if (Utils::isPositiveZero(ConstDouble->getValue()))
           return makeZeroedRegister(Ty, RegNum);
       }
 
       std::string Buffer;
       llvm::raw_string_ostream StrBuf(Buffer);
-      llvm::cast<Constant>(From)->emitPoolLabel(StrBuf, Ctx);
+      llvm::cast<Constant>(From)->emitPoolLabel(StrBuf);
       llvm::cast<Constant>(From)->setShouldBePooled(true);
-      Constant *Offset = Ctx->getConstantSym(0, StrBuf.str(), true);
+      Constant *Offset = Ctx->getConstantSym(0, StrBuf.str());
       auto *Mem = X86OperandMem::create(Func, Ty, nullptr, Offset);
       From = Mem;
     }
 
     bool NeedsReg = false;
     if (!(Allowed & Legal_Imm) && !isScalarFloatingType(Ty))
       // Immediate specifically not allowed.
       NeedsReg = true;
     if (!(Allowed & Legal_Mem) && isScalarFloatingType(Ty))
       // On x86, FP constants are lowered to mem operands.
@@ skipping 196 matching lines @@
     Ostream &Str = Ctx->getStrEmit();
     Str << "$" << C->getValue();
   }
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::emit(const ConstantFloat *C) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
-  C->emitPoolLabel(Str, Ctx);
+  C->emitPoolLabel(Str);
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::emit(const ConstantDouble *C) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
-  C->emitPoolLabel(Str, Ctx);
+  C->emitPoolLabel(Str);
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::emit(const ConstantUndef *) const {
   llvm::report_fatal_error("undef value encountered by emitter.");
 }
 
 template <class Machine>
 void TargetX86Base<Machine>::emit(const ConstantRelocatable *C) const {
   if (!BuildDefs::dump())
@@ skipping 69 matching lines @@
     //  => Reg
     assert(Ctx->getFlags().getRandomizeAndPoolImmediatesOption() == RPI_Pool);
     Immediate->setShouldBePooled(true);
     // if we have already assigned a phy register, we must come from
     // advancedPhiLowering()=>lowerAssign(). In this case we should reuse the
     // assigned register as this assignment is that start of its use-def
     // chain. So we add RegNum argument here.
     Variable *Reg = makeReg(Immediate->getType(), RegNum);
     IceString Label;
     llvm::raw_string_ostream Label_stream(Label);
-    Immediate->emitPoolLabel(Label_stream, Ctx);
+    Immediate->emitPoolLabel(Label_stream);
     constexpr RelocOffsetT Offset = 0;
-    constexpr bool SuppressMangling = true;
-    Constant *Symbol =
-        Ctx->getConstantSym(Offset, Label_stream.str(), SuppressMangling);
+    Constant *Symbol = Ctx->getConstantSym(Offset, Label_stream.str());
     constexpr Variable *NoBase = nullptr;
     X86OperandMem *MemOperand =
         X86OperandMem::create(Func, Immediate->getType(), NoBase, Symbol);
     _mov(Reg, MemOperand);
     return Reg;
   }
   }
 }
 
 template <typename TraitsType>
@@ skipping 82 matching lines @@
     // Memory operand should never exist as source operands in phi lowering
     // assignments, so there is no need to reuse any registers here. For
     // phi lowering, we should not ask for new physical registers in
     // general. However, if we do meet Memory Operand during phi lowering,
     // we should not blind or pool the immediates for now.
     if (RegNum.hasValue())
       return MemOperand;
     Variable *RegTemp = makeReg(IceType_i32);
     IceString Label;
     llvm::raw_string_ostream Label_stream(Label);
-    MemOperand->getOffset()->emitPoolLabel(Label_stream, Ctx);
+    MemOperand->getOffset()->emitPoolLabel(Label_stream);
     MemOperand->getOffset()->setShouldBePooled(true);
     constexpr RelocOffsetT SymOffset = 0;
-    constexpr bool SuppressMangling = true;
-    Constant *Symbol =
-        Ctx->getConstantSym(SymOffset, Label_stream.str(), SuppressMangling);
+    Constant *Symbol = Ctx->getConstantSym(SymOffset, Label_stream.str());
     constexpr Variable *NoBase = nullptr;
     X86OperandMem *SymbolOperand = X86OperandMem::create(
         Func, MemOperand->getOffset()->getType(), NoBase, Symbol);
     _mov(RegTemp, SymbolOperand);
     // If we have a base variable here, we should add the lea instruction
     // to add the value of the base variable to RegTemp. If there is no
     // base variable, we won't need this lea instruction.
     if (MemOperand->getBase()) {
       X86OperandMem *CalculateOperand = X86OperandMem::create(
           Func, MemOperand->getType(), MemOperand->getBase(), nullptr, RegTemp,
           0, MemOperand->getSegmentRegister());
       _lea(RegTemp, CalculateOperand);
     }
     X86OperandMem *NewMemOperand = X86OperandMem::create(
         Func, MemOperand->getType(), RegTemp, nullptr, MemOperand->getIndex(),
         MemOperand->getShift(), MemOperand->getSegmentRegister());
     return NewMemOperand;
   }
   }
 }
 
 template <typename TraitsType>
 void TargetX86Base<TraitsType>::emitJumpTable(
     const Cfg *Func, const InstJumpTable *JumpTable) const {
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
   const bool UseNonsfi = Ctx->getFlags().getUseNonsfi();
-  const IceString MangledName = Ctx->mangleName(Func->getFunctionName());
+  const IceString &FunctionName = Func->getFunctionName();
   const IceString Prefix = UseNonsfi ? ".data.rel.ro." : ".rodata.";
-  Str << "\t.section\t" << Prefix << MangledName
+  Str << "\t.section\t" << Prefix << FunctionName
       << "$jumptable,\"a\",@progbits\n";
   Str << "\t.align\t" << typeWidthInBytes(getPointerType()) << "\n";
-  Str << InstJumpTable::makeName(MangledName, JumpTable->getId()) << ":";
+  Str << InstJumpTable::makeName(FunctionName, JumpTable->getId()) << ":";
 
   // On X86 ILP32 pointers are 32-bit hence the use of .long
   for (SizeT I = 0; I < JumpTable->getNumTargets(); ++I)
     Str << "\n\t.long\t" << JumpTable->getTarget(I)->getAsmName();
   Str << "\n";
 }
 
 template <typename TraitsType>
 template <typename T>
 void TargetDataX86<TraitsType>::emitConstantPool(GlobalContext *Ctx) {
@@ skipping 28 matching lines @@
     // Use memcpy() to copy bits from Value into RawValue in a way that avoids
     // breaking strict-aliasing rules.
     typename T::PrimitiveIntType RawValue;
     memcpy(&RawValue, &Value, sizeof(Value));
     char buf[30];
     int CharsPrinted =
         snprintf(buf, llvm::array_lengthof(buf), T::PrintfString, RawValue);
     assert(CharsPrinted >= 0);
     assert((size_t)CharsPrinted < llvm::array_lengthof(buf));
     (void)CharsPrinted; // avoid warnings if asserts are disabled
-    Const->emitPoolLabel(Str, Ctx);
+    Const->emitPoolLabel(Str);
     Str << ":\n\t" << T::AsmTag << "\t" << buf << "\t/* " << T::TypeName << " "
         << Value << " */\n";
   }
 }
 
 template <typename TraitsType>
 void TargetDataX86<TraitsType>::lowerConstants() {
   if (Ctx->getFlags().getDisableTranslation())
     return;
   switch (Ctx->getFlags().getOutFileType()) {
@@ skipping 71 matching lines @@
         emitGlobal(*Var, SectionSuffix);
       }
     }
   } break;
   }
 }
 } // end of namespace X86NAMESPACE
 } // end of namespace Ice
 
 #endif // SUBZERO_SRC_ICETARGETLOWERINGX86BASEIMPL_H