Fix subzero Windows build

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.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file defines the writer for ELF relocatable object files.
@@ skipping 264 matching lines @@
 
 // Partition the Vars list by SectionType into VarsBySection.
 // If TranslateOnly is non-empty, then only the TranslateOnly variable
 // is kept for emission.
 void partitionGlobalsBySection(const VariableDeclarationList &Vars,
                                VariableDeclarationList VarsBySection[],
                                const IceString &TranslateOnly) {
   for (VariableDeclaration *Var : Vars) {
     if (GlobalContext::matchSymbolName(Var->getName(), TranslateOnly)) {
       size_t Section = classifyGlobalSection(Var);
-      assert(Section < ELFObjectWriter::SectionType::NumSectionTypes);
+      assert(Section < ELFObjectWriter::NumSectionTypes);
       VarsBySection[Section].push_back(Var);
     }
   }
 }
 
 } // end of anonymous namespace
 
 void ELFObjectWriter::writeDataSection(const VariableDeclarationList &Vars,
                                        FixupKind RelocationKind) {
   assert(!SectionNumbersAssigned);
   VariableDeclarationList VarsBySection[ELFObjectWriter::NumSectionTypes];
   for (auto &SectionList : VarsBySection)
     SectionList.reserve(Vars.size());
   partitionGlobalsBySection(Vars, VarsBySection, Ctx.getFlags().TranslateOnly);
   bool IsELF64 = isELF64(Ctx.getTargetArch());
   size_t I = 0;
   for (auto &SectionList : VarsBySection) {
     writeDataOfType(static_cast<SectionType>(I++), SectionList, RelocationKind,
                     IsELF64);
   }
 }
 
-void ELFObjectWriter::writeDataOfType(SectionType SectionType,
+void ELFObjectWriter::writeDataOfType(SectionType ST,
                                       const VariableDeclarationList &Vars,
                                       FixupKind RelocationKind, bool IsELF64) {
   ELFDataSection *Section;
   ELFRelocationSection *RelSection;
   // TODO(jvoung): Handle fdata-sections.
   IceString SectionName;
   Elf64_Xword ShAddralign = 0;
   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 (SectionType) {
-  case SectionType::ROData: {
+  switch (ST) {
+  case ROData: {
     SectionName = ".rodata";
     // Only expecting to write the data sections all in one shot for now.
     assert(RODataSections.empty());
     const Elf64_Xword ShFlags = SHF_ALLOC;
     Section = createSection<ELFDataSection>(SectionName, SHT_PROGBITS, ShFlags,
                                             ShAddralign, ShEntsize);
     Section->setFileOffset(alignFileOffset(ShAddralign));
     RODataSections.push_back(Section);
     RelSection = createRelocationSection(IsELF64, Section);
     RelRODataSections.push_back(RelSection);
     break;
   }
-  case SectionType::Data: {
+  case Data: {
     SectionName = ".data";
     assert(DataSections.empty());
     const 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(IsELF64, Section);
     RelDataSections.push_back(RelSection);
     break;
   }
-  case SectionType::BSS: {
+  case BSS: {
     SectionName = ".bss";
     assert(BSSSections.empty());
     const 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 SectionType::NumSectionTypes:
+  case NumSectionTypes:
     llvm::report_fatal_error("Unknown SectionType");
     break;
   }
 
   const uint8_t SymbolType = STT_OBJECT;
   for (VariableDeclaration *Var : Vars) {
     Elf64_Xword Align = Var->getAlignment();
     Section->padToAlignment(Str, Align);
     SizeT SymbolSize = Var->getNumBytes();
     bool IsExternal = Var->isExternal() || Ctx.getFlags().DisableInternal;
     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()) {
-      assert(SectionType == SectionType::BSS ||
-             SectionType == SectionType::ROData);
-      if (SectionType == SectionType::ROData)
+      assert(ST == BSS || ST == ROData);
+      if (ST == ROData)
         Section->appendZeros(Str, SymbolSize);
       else
         Section->setSize(Section->getCurrentSize() + SymbolSize);
     } else {
-      assert(SectionType != SectionType::BSS);
+      assert(ST != BSS);
       for (VariableDeclaration::Initializer *Init : Var->getInitializers()) {
         switch (Init->getKind()) {
         case VariableDeclaration::Initializer::DataInitializerKind: {
           const auto Data = llvm::cast<VariableDeclaration::DataInitializer>(
                                 Init)->getContents();
           Section->appendData(Str, llvm::StringRef(Data.data(), Data.size()));
           break;
         }
         case VariableDeclaration::Initializer::ZeroInitializerKind:
           Section->appendZeros(Str, Init->getNumBytes());
@@ skipping 199 matching lines @@
   if (IsELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice