Subzero: Refactor x86 register definitions to use the alias mechanism.

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 97 matching lines @@
   // 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 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");
-  const Elf64_Xword ShFlags = 0;
+  constexpr Elf64_Xword ShFlags = 0;
   ELFRelocationSection *RelSection = createSection<ELFRelocationSection>(
       RelSectionName, ShType, ShFlags, ShAlign, ShEntSize);
   RelSection->setRelatedSection(RelatedSection);
   return RelSection;
 }
 
 template <typename UserSectionList>
 void ELFObjectWriter::assignRelSectionNumInPairs(SizeT &CurSectionNumber,
                                                  UserSectionList &UserSections,
                                                  RelSectionList &RelSections,
@@ skipping 82 matching lines @@
 void ELFObjectWriter::writeFunctionCode(const IceString &FuncName,
                                         bool IsInternal, const Assembler *Asm) {
   assert(!SectionNumbersAssigned);
   ELFTextSection *Section = nullptr;
   ELFRelocationSection *RelSection = nullptr;
   const bool FunctionSections = Ctx.getFlags().getFunctionSections();
   if (TextSections.empty() || FunctionSections) {
     IceString SectionName = ".text";
     if (FunctionSections)
       SectionName += "." + FuncName;
-    const Elf64_Xword ShFlags = SHF_ALLOC | SHF_EXECINSTR;
+    constexpr Elf64_Xword ShFlags = SHF_ALLOC | SHF_EXECINSTR;
     const Elf64_Xword ShAlign = 1 << Asm->getBundleAlignLog2Bytes();
     Section = createSection<ELFTextSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAlign, 0);
     Elf64_Off OffsetInFile = alignFileOffset(Section->getSectionAlign());
     Section->setFileOffset(OffsetInFile);
     TextSections.push_back(Section);
     RelSection = createRelocationSection(Section);
     RelTextSections.push_back(RelSection);
   } else {
     Section = TextSections[0];
@@ skipping 83 matching lines @@
   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);
   }
-  const Elf64_Xword ShEntsize = 0; // non-uniform data element size.
+  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 = MangleSectionName(".rodata", SectionSuffix);
-    const Elf64_Xword ShFlags = SHF_ALLOC;
+    constexpr Elf64_Xword ShFlags = SHF_ALLOC;
     Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAddralign, ShEntsize);
     Section->setFileOffset(alignFileOffset(ShAddralign));
     RODataSections.push_back(Section);
     RelSection = createRelocationSection(Section);
     RelRODataSections.push_back(RelSection);
     break;
   }
   case Data: {
     const IceString SectionName = MangleSectionName(".data", SectionSuffix);
-    const Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
+    constexpr Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
     Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAddralign, ShEntsize);
     Section->setFileOffset(alignFileOffset(ShAddralign));
     DataSections.push_back(Section);
     RelSection = createRelocationSection(Section);
     RelDataSections.push_back(RelSection);
     break;
   }
   case BSS: {
     const IceString SectionName = MangleSectionName(".bss", SectionSuffix);
-    const Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
+    constexpr Elf64_Xword ShFlags = SHF_ALLOC | SHF_WRITE;
     Section = createSection<ELFDataSection>(SectionName, SHT_NOBITS, ShFlags,
                                             ShAddralign, ShEntsize);
     Section->setFileOffset(alignFileOffset(ShAddralign));
     BSSSections.push_back(Section);
     break;
   }
   case NumSectionTypes:
     llvm::report_fatal_error("Unknown SectionType");
     break;
   }
 
-  const uint8_t SymbolType = STT_OBJECT;
+  constexpr uint8_t SymbolType = STT_OBJECT;
   for (VariableDeclaration *Var : Vars) {
     // If the variable declaration does not have an initializer, its symtab
     // entry will be created separately.
     if (!Var->hasInitializer())
       continue;
     Elf64_Xword Align = Var->getAlignment();
-    const Elf64_Xword MinAlign = 1;
+    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,
                              Section->getCurrentSize(), SymbolSize);
     StrTab->add(MangledName);
     if (!Var->hasNonzeroInitializer()) {
@@ skipping 16 matching lines @@
         }
         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(RelocationKind);
-          const bool SuppressMangling = true;
+          constexpr bool SuppressMangling = true;
           NewFixup.set_value(Ctx.getConstantSym(
               Reloc->getOffset(), Reloc->getDeclaration()->mangleName(&Ctx),
               SuppressMangling));
           RelSection->addRelocation(NewFixup);
           Section->appendRelocationOffset(Str, RelSection->isRela(),
                                           Reloc->getOffset());
           break;
         }
         }
       }
     }
   }
 }
 
 void ELFObjectWriter::writeInitialELFHeader() {
   assert(!SectionNumbersAssigned);
-  const Elf64_Off DummySHOffset = 0;
-  const SizeT DummySHStrIndex = 0;
-  const SizeT DummyNumSections = 0;
+  constexpr Elf64_Off DummySHOffset = 0;
+  constexpr SizeT DummySHStrIndex = 0;
+  constexpr SizeT DummyNumSections = 0;
   if (ELF64) {
     writeELFHeaderInternal<true>(DummySHOffset, DummySHStrIndex,
                                  DummyNumSections);
   } else {
     writeELFHeaderInternal<false>(DummySHOffset, DummySHStrIndex,
                                   DummyNumSections);
   }
 }
 
 template <bool IsELF64>
 void ELFObjectWriter::writeELFHeaderInternal(Elf64_Off SectionHeaderOffset,
                                              SizeT SectHeaderStrIndex,
                                              SizeT NumSections) {
   // Write the e_ident: magic number, class, etc. The e_ident is byte order and
   // ELF class independent.
   Str.writeBytes(llvm::StringRef(ElfMagic, strlen(ElfMagic)));
   Str.write8(IsELF64 ? ELFCLASS64 : ELFCLASS32);
   Str.write8(ELFDATA2LSB);
   Str.write8(EV_CURRENT);
   Str.write8(ELFOSABI_NONE);
-  const uint8_t ELF_ABIVersion = 0;
+  constexpr uint8_t ELF_ABIVersion = 0;
   Str.write8(ELF_ABIVersion);
   Str.writeZeroPadding(EI_NIDENT - EI_PAD);
 
   // TODO(jvoung): Handle and test > 64K sections. See the generic ABI doc:
   // https://refspecs.linuxbase.org/elf/gabi4+/ch4.eheader.html e_shnum should
   // be 0 and then actual number of sections is stored in the sh_size member of
   // the 0th section.
   assert(NumSections < SHN_LORESERVE);
   assert(SectHeaderStrIndex < SHN_LORESERVE);
 
@@ skipping 29 matching lines @@
   }
   SizeT Align = typeAlignInBytes(Ty);
   size_t EntSize = typeWidthInBytes(Ty);
   char Buf[20];
   SizeT WriteAmt = std::min(EntSize, llvm::array_lengthof(Buf));
   // Check that we write the full PrimType.
   assert(WriteAmt == EntSize);
   // Assume that writing WriteAmt bytes at a time allows us to avoid aligning
   // between entries.
   assert(WriteAmt % Align == 0);
-  const Elf64_Xword ShFlags = SHF_ALLOC | SHF_MERGE;
+  constexpr Elf64_Xword ShFlags = SHF_ALLOC | SHF_MERGE;
   std::string SecBuffer;
   llvm::raw_string_ostream SecStrBuf(SecBuffer);
   SecStrBuf << ".rodata.cst" << WriteAmt;
   ELFDataSection *Section = createSection<ELFDataSection>(
       SecStrBuf.str(), SHT_PROGBITS, ShFlags, Align, WriteAmt);
   RODataSections.push_back(Section);
   SizeT OffsetInSection = 0;
   // The symbol table entry doesn't need to know the defined symbol's size
   // since this is in a section with a fixed Entry Size.
-  const SizeT SymbolSize = 0;
+  constexpr SizeT SymbolSize = 0;
   Section->setFileOffset(alignFileOffset(Align));
 
   // If the -reorder-pooled-constant option is set to true, we should shuffle
   // the constants before we emit them.
   if (Ctx.getFlags().shouldReorderPooledConstants() && !Pool.empty()) {
     // Use the constant's kind value as the salt for creating random number
     // generator.
     Operand::OperandKind K = (*Pool.begin())->getKind();
     RandomNumberGenerator RNG(Ctx.getFlags().getRandomSeed(),
                               RPE_PooledConstantReordering, K);
     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);
+    auto *Const = llvm::cast<ConstType>(C);
     std::string SymBuffer;
     llvm::raw_string_ostream SymStrBuf(SymBuffer);
     Const->emitPoolLabel(SymStrBuf, &Ctx);
     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));
@@ skipping 28 matching lines @@
   const Elf64_Xword ShEntsize = PointerSize;
   const IceString SectionName =
       MangleSectionName(".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);
 
-  const uint8_t SymbolType = STT_OBJECT;
+  constexpr uint8_t SymbolType = STT_OBJECT;
   Section->padToAlignment(Str, PointerSize);
   bool IsExternal = Ctx.getFlags().getDisableInternal();
   const uint8_t SymbolBinding = IsExternal ? STB_GLOBAL : STB_LOCAL;
   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));
     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 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);
@@ skipping 59 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice