Subzero: Fix symbol name mangling. Make flags global.

src/IceELFObjectWriter.cpp

 //===- subzero/src/IceELFObjectWriter.cpp - ELF object file writer --------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 99 matching lines @@
   ShStrTab->add(Name);
   return NewSection;
 }
 
 ELFRelocationSection *
 ELFObjectWriter::createRelocationSection(const ELFSection *RelatedSection) {
   // Choice of RELA vs REL is actually separate from elf64 vs elf32, but in
   // practice we've only had .rela for elf64 (x86-64). In the future, the two
   // properties may need to be decoupled and the ShEntSize can vary more.
   const Elf64_Word ShType = ELF64 ? SHT_RELA : SHT_REL;
-  IceString RelPrefix = ELF64 ? ".rela" : ".rel";
-  IceString RelSectionName = RelPrefix + RelatedSection->getName();
+  const IceString RelPrefix = ELF64 ? ".rela" : ".rel";
+  const IceString RelSectionName = RelPrefix + RelatedSection->getName();
   const Elf64_Xword ShAlign = ELF64 ? 8 : 4;
   const Elf64_Xword ShEntSize = ELF64 ? sizeof(Elf64_Rela) : sizeof(Elf32_Rel);
   static_assert(sizeof(Elf64_Rela) == 24 && sizeof(Elf32_Rel) == 8,
                 "Elf_Rel/Rela sizes cannot be derived from sizeof");
   constexpr Elf64_Xword ShFlags = 0;
   ELFRelocationSection *RelSection = createSection<ELFRelocationSection>(
       RelSectionName, ShType, ShFlags, ShAlign, ShEntSize);
   RelSection->setRelatedSection(RelatedSection);
   return RelSection;
 }
@@ skipping 195 matching lines @@
 // TODO(jvoung): Handle fdata-sections.
 void ELFObjectWriter::writeDataOfType(SectionType ST,
                                       const VariableDeclarationList &Vars,
                                       FixupKind RelocationKind,
                                       const IceString &SectionSuffix,
                                       bool IsPIC) {
   if (Vars.empty())
     return;
   ELFDataSection *Section;
   ELFRelocationSection *RelSection;
-  IceString SectionName;
   Elf64_Xword ShAddralign = 1;
   for (VariableDeclaration *Var : Vars) {
     Elf64_Xword Align = Var->getAlignment();
     ShAddralign = std::max(ShAddralign, Align);
   }
   constexpr Elf64_Xword ShEntsize = 0; // non-uniform data element size.
   // Lift this out, so it can be re-used if we do fdata-sections?
   switch (ST) {
   case ROData: {
     const IceString SectionName =
@@ skipping 38 matching lines @@
     // entry will be created separately.
     if (!Var->hasInitializer())
       continue;
     Elf64_Xword Align = Var->getAlignment();
     constexpr Elf64_Xword MinAlign = 1;
     Align = std::max(Align, MinAlign);
     Section->padToAlignment(Str, Align);
     SizeT SymbolSize = Var->getNumBytes();
     bool IsExternal = Var->isExternal() || Ctx.getFlags().getDisableInternal();
     const uint8_t SymbolBinding = IsExternal ? STB_GLOBAL : STB_LOCAL;
-    IceString MangledName = Var->mangleName(&Ctx);
-    SymTab->createDefinedSym(MangledName, SymbolType, SymbolBinding, Section,
+    const IceString &Name = Var->getName();
+    SymTab->createDefinedSym(Name, SymbolType, SymbolBinding, Section,
                              Section->getCurrentSize(), SymbolSize);
-    StrTab->add(MangledName);
+    StrTab->add(Name);
     if (!Var->hasNonzeroInitializer()) {
       assert(ST == BSS || ST == ROData);
       if (ST == ROData)
         Section->appendZeros(Str, SymbolSize);
       else
         Section->setSize(Section->getCurrentSize() + SymbolSize);
     } else {
       assert(ST != BSS);
       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();
           Section->appendData(Str, llvm::StringRef(Data.data(), Data.size()));
           break;
         }
         case VariableDeclaration::Initializer::ZeroInitializerKind:
           Section->appendZeros(Str, Init->getNumBytes());
           break;
         case VariableDeclaration::Initializer::RelocInitializerKind: {
           const auto *Reloc =
               llvm::cast<VariableDeclaration::RelocInitializer>(Init.get());
           AssemblerFixup NewFixup;
           NewFixup.set_position(Section->getCurrentSize());
           NewFixup.set_kind(Reloc->hasFixup() ? Reloc->getFixup()
                                               : RelocationKind);
           assert(NewFixup.kind() != llvm::ELF::R_ARM_NONE);
-          constexpr bool SuppressMangling = true;
           NewFixup.set_value(Ctx.getConstantSym(
-              Reloc->getOffset(), Reloc->getDeclaration()->mangleName(&Ctx),
-              SuppressMangling));
+              Reloc->getOffset(), Reloc->getDeclaration()->getName()));
           RelSection->addRelocation(NewFixup);
           Section->appendRelocationOffset(Str, RelSection->isRela(),
                                           Reloc->getOffset());
           break;
         }
         }
       }
     }
   }
 }
@@ skipping 97 matching lines @@
     RandomShuffle(Pool.begin(), Pool.end(),
                   [&RNG](uint64_t N) { return (uint32_t)RNG.next(N); });
   }
   // Write the data.
   for (Constant *C : Pool) {
     if (!C->getShouldBePooled())
       continue;
     auto *Const = llvm::cast<ConstType>(C);
     std::string SymBuffer;
     llvm::raw_string_ostream SymStrBuf(SymBuffer);
-    Const->emitPoolLabel(SymStrBuf, &Ctx);
+    Const->emitPoolLabel(SymStrBuf);
     std::string &SymName = SymStrBuf.str();
     SymTab->createDefinedSym(SymName, STT_NOTYPE, STB_LOCAL, Section,
                              OffsetInSection, SymbolSize);
     StrTab->add(SymName);
     typename ConstType::PrimType Value = Const->getValue();
     memcpy(Buf, &Value, WriteAmt);
     Str.writeBytes(llvm::StringRef(Buf, WriteAmt));
     OffsetInSection += WriteAmt;
   }
   Section->setSize(OffsetInSection);
@@ skipping 27 matching lines @@
       IsPIC ? ".data.rel.ro" : ".rodata", JT.getFunctionName() + "$jumptable");
   Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, SHF_ALLOC,
                                           ShAddralign, ShEntsize);
   Section->setFileOffset(alignFileOffset(ShAddralign));
   RODataSections.push_back(Section);
   RelSection = createRelocationSection(Section);
   RelRODataSections.push_back(RelSection);
 
   constexpr uint8_t SymbolType = STT_OBJECT;
   Section->padToAlignment(Str, PointerSize);
-  bool IsExternal = Ctx.getFlags().getDisableInternal();
+  const bool IsExternal = Ctx.getFlags().getDisableInternal();
   const uint8_t SymbolBinding = IsExternal ? STB_GLOBAL : STB_LOCAL;
-  IceString JumpTableName =
+  const IceString JumpTableName =
       InstJumpTable::makeName(JT.getFunctionName(), JT.getId());
   SymTab->createDefinedSym(JumpTableName, SymbolType, SymbolBinding, Section,
                            Section->getCurrentSize(), PointerSize);
   StrTab->add(JumpTableName);
 
   for (intptr_t TargetOffset : JT.getTargetOffsets()) {
     AssemblerFixup NewFixup;
     NewFixup.set_position(Section->getCurrentSize());
     NewFixup.set_kind(RelocationKind);
-    constexpr bool SuppressMangling = true;
-    NewFixup.set_value(Ctx.getConstantSym(TargetOffset, JT.getFunctionName(),
-                                          SuppressMangling));
+    NewFixup.set_value(Ctx.getConstantSym(TargetOffset, JT.getFunctionName()));
     RelSection->addRelocation(NewFixup);
     Section->appendRelocationOffset(Str, RelSection->isRela(), TargetOffset);
   }
 }
 
 void ELFObjectWriter::setUndefinedSyms(const ConstantList &UndefSyms) {
   for (const Constant *S : UndefSyms) {
     const auto *Sym = llvm::cast<ConstantRelocatable>(S);
     const IceString &Name = Sym->getName();
     bool BadIntrinsic;
     const Intrinsics::FullIntrinsicInfo *Info =
         Ctx.getIntrinsicsInfo().find(Name, BadIntrinsic);
     if (Info)
       continue;
     // Ignore BadIntrinsic, which is set if the name begins with "llvm." but
     // doesn't match a known intrinsic.  If we want this to turn into an error,
     // we should catch it early on.
     assert(Sym->getOffset() == 0);
-    assert(Sym->getSuppressMangling());
     SymTab->noteUndefinedSym(Name, NullSection);
     StrTab->add(Name);
   }
 }
 
 void ELFObjectWriter::writeRelocationSections(RelSectionList &RelSections) {
   for (ELFRelocationSection *RelSec : RelSections) {
     Elf64_Off Offset = alignFileOffset(RelSec->getSectionAlign());
     RelSec->setFileOffset(Offset);
     RelSec->setSize(RelSec->getSectionDataSize());
     if (ELF64) {
-      RelSec->writeData<true>(Ctx, Str, SymTab);
+      RelSec->writeData<true>(Str, SymTab);
     } else {
-      RelSec->writeData<false>(Ctx, Str, SymTab);
+      RelSec->writeData<false>(Str, SymTab);
     }
   }
 }
 
 void ELFObjectWriter::writeNonUserSections() {
   // Write out the shstrtab now that all sections are known.
   ShStrTab->doLayout();
   ShStrTab->setSize(ShStrTab->getSectionDataSize());
   Elf64_Off ShStrTabOffset = alignFileOffset(ShStrTab->getSectionAlign());
   ShStrTab->setFileOffset(ShStrTabOffset);
@@ skipping 34 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice