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 60 matching lines @@
   const IceString NullSectionName("");
   NullSection = new (Ctx.allocate<ELFSection>())
       ELFSection(NullSectionName, SHT_NULL, 0, 0, 0);
 
   const IceString ShStrTabName(".shstrtab");
   ShStrTab = new (Ctx.allocate<ELFStringTableSection>())
       ELFStringTableSection(ShStrTabName, SHT_STRTAB, 0, 1, 0);
   ShStrTab->add(ShStrTabName);
 
   const IceString SymTabName(".symtab");
   const Elf64_Xword SymTabAlign = ELF64 ? 8 : 4;

[Karl, 2015/10/27 16:13:18]

constexpr?

[Jim Stichnoth, 2015/10/27 19:14:09]

No because ELF64 is not a constexpr.

   const Elf64_Xword SymTabEntSize =
       ELF64 ? sizeof(Elf64_Sym) : sizeof(Elf32_Sym);

[Karl, 2015/10/27 16:13:18]

constexpr?

[Jim Stichnoth, 2015/10/27 19:14:09]

No because ELF64 is not a constexpr.

   static_assert(sizeof(Elf64_Sym) == 24 && sizeof(Elf32_Sym) == 16,
                 "Elf_Sym sizes cannot be derived from sizeof");
   SymTab = createSection<ELFSymbolTableSection>(SymTabName, SHT_SYMTAB, 0,
                                                 SymTabAlign, SymTabEntSize);
   SymTab->createNullSymbol(NullSection);
 
   const IceString StrTabName(".strtab");
   StrTab =
       createSection<ELFStringTableSection>(StrTabName, SHT_STRTAB, 0, 1, 0);
 }
@@ skipping 117 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;

[Karl, 2015/10/27 16:13:18]

constexpr?

[Jim Stichnoth, 2015/10/27 19:14:09]

Done.

     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 88 matching lines @@
   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.
   // 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;

[Karl, 2015/10/27 16:13:18]

constexpr?

[Jim Stichnoth, 2015/10/27 19:14:09]

Done.

     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;

[Karl, 2015/10/27 16:13:18]

constexpr?

[Jim Stichnoth, 2015/10/27 19:14:09]

Done.

     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;

[Karl, 2015/10/27 16:13:18]

constexpr?

[Jim Stichnoth, 2015/10/27 19:14:09]

Done.

     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;
   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;

[Karl, 2015/10/27 16:13:18]

constexpr?

[Jim Stichnoth, 2015/10/27 19:14:09]

Done.

     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;

[Karl, 2015/10/27 16:13:18]

constexpr?

[Jim Stichnoth, 2015/10/27 19:14:09]

no because of IsExternal.

     IceString MangledName = Var->mangleName(&Ctx);
     SymTab->createDefinedSym(MangledName, SymbolType, SymbolBinding, Section,
                              Section->getCurrentSize(), SymbolSize);
     StrTab->add(MangledName);
     if (!Var->hasNonzeroInitializer()) {
       assert(ST == BSS || ST == ROData);
       if (ST == ROData)
         Section->appendZeros(Str, SymbolSize);
       else
         Section->setSize(Section->getCurrentSize() + SymbolSize);
@@ skipping 11 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;

[Karl, 2015/10/27 16:13:18]

More constexprs?

[Jim Stichnoth, 2015/10/27 19:14:09]

Done.

   const SizeT DummySHStrIndex = 0;
   const SizeT DummyNumSections = 0;
   if (ELF64) {
     writeELFHeaderInternal<true>(DummySHOffset, DummySHStrIndex,
                                  DummyNumSections);
   } else {
     writeELFHeaderInternal<false>(DummySHOffset, DummySHStrIndex,
                                   DummyNumSections);
   }
 }
@@ skipping 80 matching lines @@
     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;

[Karl, 2015/10/27 16:13:18]

constexpr?

[Jim Stichnoth, 2015/10/27 19:14:09]

Done.

   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 38 matching lines @@
   SymTab->setSize(SymTab->getSectionDataSize());
   SymTab->writeData(Str, ELF64);
 
   Elf64_Off StrTabOffset = alignFileOffset(StrTab->getSectionAlign());
   StrTab->setFileOffset(StrTabOffset);
   Str.writeBytes(StrTab->getSectionData());
 
   writeAllRelocationSections();
 
   // Write out the section headers.
   const size_t ShdrAlign = ELF64 ? 8 : 4;

[Karl, 2015/10/27 16:13:18]

constexpr?

[Jim Stichnoth, 2015/10/27 19:14:09]

no because of ELF64.

   Elf64_Off ShOffset = alignFileOffset(ShdrAlign);
   for (const auto S : AllSections) {
     if (ELF64)
       S->writeHeader<true>(Str);
     else
       S->writeHeader<false>(Str);
   }
 
   // Finally write the updated ELF header w/ the correct number of sections.
   Str.seek(0);
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice