Subzero: Add Non-SFI support for x86-32.

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 267 matching lines @@
       assert(Section < ELFObjectWriter::NumSectionTypes);
       VarsBySection[Section].push_back(Var);
     }
   }
 }
 
 } // end of anonymous namespace
 
 void ELFObjectWriter::writeDataSection(const VariableDeclarationList &Vars,
                                        FixupKind RelocationKind,
-                                       const IceString &SectionSuffix) {
+                                       const IceString &SectionSuffix,
+                                       bool IsPIC) {
   assert(!SectionNumbersAssigned);
   VariableDeclarationList VarsBySection[ELFObjectWriter::NumSectionTypes];
   for (auto &SectionList : VarsBySection)
     SectionList.reserve(Vars.size());
   partitionGlobalsBySection(Vars, VarsBySection,
                             Ctx.getFlags().getTranslateOnly());
   size_t I = 0;
   for (auto &SectionList : VarsBySection) {
     writeDataOfType(static_cast<SectionType>(I++), SectionList, RelocationKind,
-                    SectionSuffix);
+                    SectionSuffix, IsPIC);
   }
 }
 
 namespace {
 IceString MangleSectionName(const char Base[], const IceString &Suffix) {
   if (Suffix.empty())
     return Base;
   return Base + ("." + Suffix);
 }
 } // end of anonymous namespace
 
 // TODO(jvoung): Handle fdata-sections.
 void ELFObjectWriter::writeDataOfType(SectionType ST,
                                       const VariableDeclarationList &Vars,
                                       FixupKind RelocationKind,
-                                      const IceString &SectionSuffix) {
+                                      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 = MangleSectionName(".rodata", SectionSuffix);
-    constexpr Elf64_Xword ShFlags = SHF_ALLOC;
+    const IceString SectionName =
+        MangleSectionName(IsPIC ? ".data.rel.ro" : ".rodata", SectionSuffix);
+    const Elf64_Xword ShFlags = SHF_ALLOC | (IsPIC ? SHF_WRITE : 0);
     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);
@@ skipping 209 matching lines @@
 
 template void ELFObjectWriter::writeConstantPool<ConstantInteger32>(Type Ty);
 
 void ELFObjectWriter::writeAllRelocationSections() {
   writeRelocationSections(RelTextSections);
   writeRelocationSections(RelDataSections);
   writeRelocationSections(RelRODataSections);
 }
 
 void ELFObjectWriter::writeJumpTable(const JumpTableData &JT,
-                                     FixupKind RelocationKind) {
+                                     FixupKind RelocationKind, bool IsPIC) {
   ELFDataSection *Section;
   ELFRelocationSection *RelSection;
   const Elf64_Xword PointerSize = typeWidthInBytes(getPointerType());
   const Elf64_Xword ShAddralign = PointerSize;
   const Elf64_Xword ShEntsize = PointerSize;
-  const IceString SectionName =
-      MangleSectionName(".rodata", JT.getFunctionName() + "$jumptable");
+  const IceString SectionName = MangleSectionName(
+      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();
@@ skipping 91 matching lines @@
   if (ELF64) {
     writeELFHeaderInternal<true>(ShOffset, ShStrTab->getNumber(),
                                  AllSections.size());
   } else {
     writeELFHeaderInternal<false>(ShOffset, ShStrTab->getNumber(),
                                   AllSections.size());
   }
 }
 
 } // end of namespace Ice