Subzero: Fix symbol name mangling. Make flags global.

src/IceTargetLowering.cpp

 //===- subzero/src/IceTargetLowering.cpp - Basic lowering implementation --===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 711 matching lines @@
   if (!BuildDefs::dump())
     return;
   Ostream &Str = Ctx->getStrEmit();
   const IceString &EmitStr = C->getEmitString();
   if (!EmitStr.empty()) {
     // C has a custom emit string, so we use it instead of the canonical
     // Name + Offset form.
     Str << EmitStr;
     return;
   }
-  if (C->getSuppressMangling())
-    Str << C->getName();
-  else
-    Str << Ctx->mangleName(C->getName());
-  Str << Suffix;
+  Str << C->getName() << Suffix;
   RelocOffsetT Offset = C->getOffset();
   if (Offset) {
     if (Offset > 0)
       Str << "+";
     Str << Offset;
   }
 }
 
 std::unique_ptr<TargetDataLowering>
 TargetDataLowering::createLowering(GlobalContext *Ctx) {
   TargetArch Target = Ctx->getFlags().getTargetArch();
   switch (Target) {
   default:
     badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X:                                                             \
     return ::X::createTargetDataLowering(Ctx);
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetDataLowering::~TargetDataLowering() = default;
 
 namespace {
 
-// dataSectionSuffix decides whether to use SectionSuffix or MangledVarName as
-// data section suffix. Essentially, when using separate data sections for
-// globals SectionSuffix is not necessary.
+// dataSectionSuffix decides whether to use SectionSuffix or VarName as data
+// section suffix. Essentially, when using separate data sections for globals
+// SectionSuffix is not necessary.
 IceString dataSectionSuffix(const IceString &SectionSuffix,
-                            const IceString &MangledVarName,
-                            const bool DataSections) {
+                            const IceString &VarName, const bool DataSections) {
   if (SectionSuffix.empty() && !DataSections) {
     return "";
   }
 
   if (DataSections) {
     // With data sections we don't need to use the SectionSuffix.
-    return "." + MangledVarName;
+    return "." + VarName;
   }
 
   assert(!SectionSuffix.empty());
   return "." + SectionSuffix;
 }
 
 } // end of anonymous namespace
 
 void TargetDataLowering::emitGlobal(const VariableDeclaration &Var,
                                     const IceString &SectionSuffix) {
   if (!BuildDefs::dump())
     return;
 
   // If external and not initialized, this must be a cross test. Don't generate
   // a declaration for such cases.
   const bool IsExternal =
       Var.isExternal() || Ctx->getFlags().getDisableInternal();
   if (IsExternal && !Var.hasInitializer())
     return;
 
   Ostream &Str = Ctx->getStrEmit();
   const bool HasNonzeroInitializer = Var.hasNonzeroInitializer();
   const bool IsConstant = Var.getIsConstant();
   const SizeT Size = Var.getNumBytes();
-  const IceString MangledName = Var.mangleName(Ctx);
+  const IceString &Name = Var.getName();
 
-  Str << "\t.type\t" << MangledName << ",%object\n";
+  Str << "\t.type\t" << Name << ",%object\n";
 
   const bool UseDataSections = Ctx->getFlags().getDataSections();
   const bool UseNonsfi = Ctx->getFlags().getUseNonsfi();
   const IceString Suffix =
-      dataSectionSuffix(SectionSuffix, MangledName, UseDataSections);
+      dataSectionSuffix(SectionSuffix, Name, UseDataSections);
   if (IsConstant && UseNonsfi)
     Str << "\t.section\t.data.rel.ro" << Suffix << ",\"aw\",%progbits\n";
   else if (IsConstant)
     Str << "\t.section\t.rodata" << Suffix << ",\"a\",%progbits\n";
   else if (HasNonzeroInitializer)
     Str << "\t.section\t.data" << Suffix << ",\"aw\",%progbits\n";
   else
     Str << "\t.section\t.bss" << Suffix << ",\"aw\",%nobits\n";
 
   if (IsExternal)
-    Str << "\t.globl\t" << MangledName << "\n";
+    Str << "\t.globl\t" << Name << "\n";
 
   const uint32_t Align = Var.getAlignment();
   if (Align > 1) {
     assert(llvm::isPowerOf2_32(Align));
     // Use the .p2align directive, since the .align N directive can either
     // interpret N as bytes, or power of 2 bytes, depending on the target.
     Str << "\t.p2align\t" << llvm::Log2_32(Align) << "\n";
   }
 
-  Str << MangledName << ":\n";
+  Str << Name << ":\n";
 
   if (HasNonzeroInitializer) {
     for (const std::unique_ptr<VariableDeclaration::Initializer> &Init :
          Var.getInitializers()) {
       switch (Init->getKind()) {
       case VariableDeclaration::Initializer::DataInitializerKind: {
         const auto &Data =
             llvm::cast<VariableDeclaration::DataInitializer>(Init.get())
                 ->getContents();
         for (SizeT i = 0; i < Init->getNumBytes(); ++i) {
           Str << "\t.byte\t" << (((unsigned)Data[i]) & 0xff) << "\n";
         }
         break;
       }
       case VariableDeclaration::Initializer::ZeroInitializerKind:
         Str << "\t.zero\t" << Init->getNumBytes() << "\n";
         break;
       case VariableDeclaration::Initializer::RelocInitializerKind: {
         const auto *Reloc =
             llvm::cast<VariableDeclaration::RelocInitializer>(Init.get());
         Str << "\t" << getEmit32Directive() << "\t";
-        Str << Reloc->getDeclaration()->mangleName(Ctx);
+        Str << Reloc->getDeclaration()->getName();
         if (Reloc->hasFixup()) {
           // TODO(jpp): this is ARM32 specific.
           Str << "(GOTOFF)";
         }
         if (RelocOffsetT Offset = Reloc->getOffset()) {
           if (Offset >= 0 || (Offset == INT32_MIN))
             Str << " + " << Offset;
           else
             Str << " - " << -Offset;
         }
         Str << "\n";
         break;
       }
       }
     }
   } else {
     // NOTE: for non-constant zero initializers, this is BSS (no bits), so an
     // ELF writer would not write to the file, and only track virtual offsets,
     // but the .s writer still needs this .zero and cannot simply use the .size
     // to advance offsets.
     Str << "\t.zero\t" << Size << "\n";
   }
 
-  Str << "\t.size\t" << MangledName << ", " << Size << "\n";
+  Str << "\t.size\t" << Name << ", " << Size << "\n";
 }
 
 std::unique_ptr<TargetHeaderLowering>
 TargetHeaderLowering::createLowering(GlobalContext *Ctx) {
   TargetArch Target = Ctx->getFlags().getTargetArch();
   switch (Target) {
   default:
     badTargetFatalError(Target);
 #define SUBZERO_TARGET(X)                                                      \
   case Target_##X:                                                             \
     return ::X::createTargetHeaderLowering(Ctx);
 #include "llvm/Config/SZTargets.def"
 #undef SUBZERO_TARGET
   }
 }
 
 TargetHeaderLowering::~TargetHeaderLowering() = default;
 
 } // end of namespace Ice