Write out global initializers and data rel directly to ELF file.

src/IceTargetLoweringX8632.cpp

 //===- subzero/src/IceTargetLoweringX8632.cpp - x86-32 lowering -----------===//
 //
 //                        The Subzero Code Generator
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This file implements the TargetLoweringX8632 class, which
@@ skipping 4542 matching lines @@
   if (!ALLOW_DUMP)
     return;
   Ostream &Str = Ctx->getStrEmit();
   emitPoolLabel(Str);
 }
 
 void ConstantUndef::emit(GlobalContext *) const {
   llvm_unreachable("undef value encountered by emitter.");
 }
 
-TargetGlobalX8632::TargetGlobalX8632(GlobalContext *Ctx)
-    : TargetGlobalLowering(Ctx) {}
+TargetDataX8632::TargetDataX8632(GlobalContext *Ctx)
+    : TargetDataLowering(Ctx) {}
 
-void TargetGlobalX8632::lowerInit(const VariableDeclaration &Var) const {
-  // TODO(jvoung): handle this without text.
-  if (Ctx->getFlags().UseELFWriter)
-    return;
-
-  Ostream &Str = Ctx->getStrEmit();
-
-  const VariableDeclaration::InitializerListType &Initializers =
-      Var.getInitializers();
-
+void TargetDataX8632::lowerGlobal(const VariableDeclaration &Var) const {
   // If external and not initialized, this must be a cross test.
   // Don't generate a declaration for such cases.
   bool IsExternal = Var.isExternal() || Ctx->getFlags().DisableInternal;
   if (IsExternal && !Var.hasInitializer())
     return;
 
+  Ostream &Str = Ctx->getStrEmit();
+  const VariableDeclaration::InitializerListType &Initializers =
+      Var.getInitializers();
   bool HasNonzeroInitializer = Var.hasNonzeroInitializer();
   bool IsConstant = Var.getIsConstant();
   uint32_t Align = Var.getAlignment();
   SizeT Size = Var.getNumBytes();
   IceString MangledName = Var.mangleName(Ctx);
   IceString SectionSuffix = "";
   if (Ctx->getFlags().DataSections)
     SectionSuffix = "." + MangledName;
 
   Str << "\t.type\t" << MangledName << ",@object\n";
@@ skipping 46 matching lines @@
   } else
     // NOTE: for non-constant zero initializers, this is BSS (no bits),
     // so an ELF writer would not write to the file, and only track
     // virtual offsets, but the .s writer still needs this .zero and
     // cannot simply use the .size to advance offsets.
     Str << "\t.zero\t" << Size << "\n";
 
   Str << "\t.size\t" << MangledName << ", " << Size << "\n";
 }
 
+void
+TargetDataX8632::lowerGlobalsELF(const VariableDeclarationList &Vars) const {
+  ELFObjectWriter *Writer = Ctx->getObjectWriter();
+  Writer->writeDataSection(Vars, llvm::ELF::R_386_32);
+}
+
 template <typename T> struct PoolTypeConverter {};
 
 template <> struct PoolTypeConverter<float> {
   typedef uint32_t PrimitiveIntType;
   typedef ConstantFloat IceType;
   static const Type Ty = IceType_f32;
   static const char *TypeName;
   static const char *AsmTag;
   static const char *PrintfString;
 };
 const char *PoolTypeConverter<float>::TypeName = "float";
 const char *PoolTypeConverter<float>::AsmTag = ".long";
 const char *PoolTypeConverter<float>::PrintfString = "0x%x";
 
 template <> struct PoolTypeConverter<double> {
   typedef uint64_t PrimitiveIntType;
   typedef ConstantDouble IceType;
   static const Type Ty = IceType_f64;
   static const char *TypeName;
   static const char *AsmTag;
   static const char *PrintfString;
 };
 const char *PoolTypeConverter<double>::TypeName = "double";
 const char *PoolTypeConverter<double>::AsmTag = ".quad";
 const char *PoolTypeConverter<double>::PrintfString = "0x%llx";
 
 template <typename T>
-void TargetGlobalX8632::emitConstantPool(GlobalContext *Ctx) {
+void TargetDataX8632::emitConstantPool(GlobalContext *Ctx) {
   // Note: Still used by emit IAS.
   Ostream &Str = Ctx->getStrEmit();
   Type Ty = T::Ty;
   SizeT Align = typeAlignInBytes(Ty);
   ConstantList Pool = Ctx->getConstantPool(Ty);
 
   Str << "\t.section\t.rodata.cst" << Align << ",\"aM\",@progbits," << Align
       << "\n";
   Str << "\t.align\t" << Align << "\n";
   for (Constant *C : Pool) {
     typename T::IceType *Const = llvm::cast<typename T::IceType>(C);
     typename T::IceType::PrimType Value = Const->getValue();
     // Use memcpy() to copy bits from Value into RawValue in a way
     // that avoids breaking strict-aliasing rules.
     typename T::PrimitiveIntType RawValue;
     memcpy(&RawValue, &Value, sizeof(Value));
     char buf[30];
     int CharsPrinted =
         snprintf(buf, llvm::array_lengthof(buf), T::PrintfString, RawValue);
     assert(CharsPrinted >= 0 &&
            (size_t)CharsPrinted < llvm::array_lengthof(buf));
     (void)CharsPrinted; // avoid warnings if asserts are disabled
     Const->emitPoolLabel(Str);
     Str << ":\n\t" << T::AsmTag << "\t" << buf << "\t# " << T::TypeName << " "
         << Value << "\n";
   }
 }
 
-void TargetGlobalX8632::lowerConstants(GlobalContext *Ctx) const {
+void TargetDataX8632::lowerConstants(GlobalContext *Ctx) const {
   if (Ctx->getFlags().DisableTranslation)
     return;
   // No need to emit constants from the int pool since (for x86) they
   // are embedded as immediates in the instructions, just emit float/double.
   if (Ctx->getFlags().UseELFWriter) {
     ELFObjectWriter *Writer = Ctx->getObjectWriter();
     Writer->writeConstantPool<ConstantFloat>(IceType_f32);
     Writer->writeConstantPool<ConstantDouble>(IceType_f64);
   } else {
     OstreamLocker L(Ctx);
     emitConstantPool<PoolTypeConverter<float>>(Ctx);
     emitConstantPool<PoolTypeConverter<double>>(Ctx);
   }
 }
 
 } // end of namespace Ice