Subzero: Add basic ELFObjectWriter (text section, symtab, strtab, headers)

src/IceCfg.cpp

 //===- subzero/src/IceCfg.cpp - Control flow graph implementation ---------===//
 //
 //                        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 Cfg class, including constant pool
@@ skipping 387 matching lines @@
 void Cfg::emitTextHeader(const IceString &MangledName) {
   // Note: Still used by emit IAS.
   Ostream &Str = Ctx->getStrEmit();
   Str << "\t.text\n";
   if (Ctx->getFlags().FunctionSections)
     Str << "\t.section\t.text." << MangledName << ",\"ax\",@progbits\n";
   if (!getInternal() || Ctx->getFlags().DisableInternal) {
     Str << "\t.globl\t" << MangledName << "\n";
     Str << "\t.type\t" << MangledName << ",@function\n";
   }
-  Str << "\t.p2align " << getTarget()->getBundleAlignLog2Bytes() << ",0x";
-  for (AsmCodeByte I : getTarget()->getNonExecBundlePadding())
+  Assembler *Asm = getAssembler<Assembler>();
+  Str << "\t.p2align " << Asm->getBundleAlignLog2Bytes() << ",0x";
+  for (uint8_t I : Asm->getNonExecBundlePadding())
     Str.write_hex(I);
   Str << "\n";
   Str << MangledName << ":\n";
 }
 
 void Cfg::emit() {
   if (!ALLOW_DUMP)
     return;
   TimerMarker T(TimerStack::TT_emit, this);
   if (Ctx->getFlags().DecorateAsm) {
@@ skipping 17 matching lines @@
   emitTextHeader(MangledName);
   for (CfgNode *Node : Nodes)
     Node->emit(this);
   Str << "\n";
 }
 
 void Cfg::emitIAS() {
   TimerMarker T(TimerStack::TT_emit, this);
   assert(!Ctx->getFlags().DecorateAsm);
   IceString MangledName = getContext()->mangleName(getFunctionName());
-  emitTextHeader(MangledName);
+  if (!Ctx->getFlags().UseELFWriter)
+    emitTextHeader(MangledName);
   for (CfgNode *Node : Nodes)
     Node->emitIAS(this);
-  getAssembler<Assembler>()->emitIASBytes(Ctx);
+  // Now write the function to the file and track.
+  if (Ctx->getFlags().UseELFWriter) {
+    getAssembler<Assembler>()->alignFunction();
+    Ctx->getObjectWriter()->writeFunctionCode(
+        MangledName, getInternal(), getAssembler<Assembler>()->getBufferView());
+    // Transfer remaining fixups too. They may need their offsets adjusted.

[Jim Stichnoth, 2014/11/21 21:32:22]

Is this a TODO, or ... ?

[jvoung (off chromium), 2014/11/24 21:35:45]

Yes, a TODO and made that explicit.

Currently the ELF writer doesn't know anything about the actual target, besides
the couple of extra entries in the .defs file. So it doesn't know about
target-specific relocations. The assembler has target-specific overrides, but
then it uses the relocation enums in IceFixups.h, which are generic.

So we need to do something there. Perhaps the assembler should specify the
target-specific relocation type right away. LLVM does keep a generic-ish fixup
layer, but that might be because it has to handle ELF, Macho and Coff. I'll look
at it more.

We might also need a target hook if we want the assembler to make another pass
through and handle function calls to the same section that can be fixed w/out
waiting on the linker, and then not bother writing out those relocations.
Otherwise, we can leave it to the linker (probably just start with that).

+  } else {
+    getAssembler<Assembler>()->emitIASBytes(Ctx);
+  }
 }
 
 // Dumps the IR with an optional introductory message.
 void Cfg::dump(const IceString &Message) {
   if (!ALLOW_DUMP)
     return;
   if (!Ctx->isVerbose())
     return;
   Ostream &Str = Ctx->getStrDump();
   if (!Message.empty())
@@ skipping 28 matching lines @@
     }
   }
   // Print each basic block
   for (CfgNode *Node : Nodes)
     Node->dump(this);
   if (getContext()->isVerbose(IceV_Instructions))
     Str << "}\n";
 }
 
 } // end of namespace Ice