prepare for a change I'm about to make

[oota-llvm.git] / lib / CodeGen / ELFWriter.cpp

diff --git a/lib/CodeGen/ELFWriter.cpp b/lib/CodeGen/ELFWriter.cpp
index cdbc13a20f19011ecc8613939244bba4f5a6dd11..4f041c27375866b7f43b9f65962da84db9cc3f89 100644 (file)
--- a/lib/CodeGen/ELFWriter.cpp
+++ b/lib/CodeGen/ELFWriter.cpp
@@ -25,7 +25,6 @@
 //  #3. ".bss" entry  - global variables without initializers.  [ if needed ]
 //  ...
 //  #N. ".shstrtab" entry - String table for the section names.
-
 //
 // NOTE: This code should eventually be extended to support 64-bit ELF (this
 // won't be hard), but we haven't done so yet!
@@ -36,8 +35,10 @@
 #include "llvm/Module.h"
 #include "llvm/CodeGen/MachineCodeEmitter.h"
 #include "llvm/CodeGen/MachineConstantPool.h"
+#include "llvm/Target/TargetData.h"
 #include "llvm/Target/TargetMachine.h"
 #include "llvm/Support/Mangler.h"
+#include <iostream>
 using namespace llvm;
 
 //===----------------------------------------------------------------------===//
@@ -56,37 +57,26 @@ namespace llvm {
     ELFCodeEmitter(ELFWriter &ew) : EW(ew), OutBuffer(0) {}
 
     void startFunction(MachineFunction &F);
-    void finishFunction(MachineFunction &F);
+    bool finishFunction(MachineFunction &F);
 
-    void emitConstantPool(MachineConstantPool *MCP) {
-      if (MCP->isEmpty()) return;
-      assert(0 && "unimp");
-    }
-    virtual void emitByte(unsigned char B) {
-      OutBuffer->push_back(B);
-    }
-    virtual void emitWordAt(unsigned W, unsigned *Ptr) {
-      assert(0 && "ni");
-    }
-    virtual void emitWord(unsigned W) {
-      assert(0 && "ni");
-    }
-    virtual uint64_t getCurrentPCValue() {
-      return OutBuffer->size();
-    }
-    virtual uint64_t getCurrentPCOffset() {
-      return OutBuffer->size()-FnStart;
-    }
     void addRelocation(const MachineRelocation &MR) {
       assert(0 && "relo not handled yet!");
     }
-    virtual uint64_t getConstantPoolEntryAddress(unsigned Index) {
+    
+    virtual void StartMachineBasicBlock(MachineBasicBlock *MBB) {
+    }
+
+    virtual intptr_t getConstantPoolEntryAddress(unsigned Index) const {
       assert(0 && "CP not implementated yet!");
       return 0;
     }
+    virtual intptr_t getJumpTableEntryAddress(unsigned Index) const {
+      assert(0 && "JT not implementated yet!");
+      return 0;
+    }
 
-    virtual unsigned char* allocateGlobal(unsigned size, unsigned alignment) {
-      assert(0 && "Globals not implemented yet!");
+    virtual intptr_t getMachineBasicBlockAddress(MachineBasicBlock *MBB) const {
+      assert(0 && "JT not implementated yet!");
       return 0;
     }
 
@@ -113,6 +103,10 @@ void ELFCodeEmitter::startFunction(MachineFunction &F) {
                       ELFWriter::ELFSection::SHF_EXECINSTR |
                       ELFWriter::ELFSection::SHF_ALLOC);
   OutBuffer = &ES->SectionData;
+  std::cerr << "FIXME: This code needs to be updated for changes in the"
+            << " CodeEmitter interfaces.  In particular, this should set "
+            << "BufferBegin/BufferEnd/CurBufferPtr, not deal with OutBuffer!";
+  abort();
 
   // Upgrade the section alignment if required.
   if (ES->Align < Align) ES->Align = Align;
@@ -127,7 +121,7 @@ void ELFCodeEmitter::startFunction(MachineFunction &F) {
 
 /// finishFunction - This callback is invoked after the function is completely
 /// finished.
-void ELFCodeEmitter::finishFunction(MachineFunction &F) {
+bool ELFCodeEmitter::finishFunction(MachineFunction &F) {
   // We now know the size of the function, add a symbol to represent it.
   ELFWriter::ELFSym FnSym(F.getFunction());
 
@@ -157,6 +151,7 @@ void ELFCodeEmitter::finishFunction(MachineFunction &F) {
 
   // Finally, add it to the symtab.
   EW.SymbolTable.push_back(FnSym);
+  return false;
 }
 
 //===----------------------------------------------------------------------===//
@@ -167,8 +162,8 @@ ELFWriter::ELFWriter(std::ostream &o, TargetMachine &tm) : O(o), TM(tm) {
   e_machine = 0;  // e_machine defaults to 'No Machine'
   e_flags = 0;    // e_flags defaults to 0, no flags.
 
-  is64Bit = TM.getTargetData().getPointerSizeInBits() == 64;
-  isLittleEndian = TM.getTargetData().isLittleEndian();
+  is64Bit = TM.getTargetData()->getPointerSizeInBits() == 64;
+  isLittleEndian = TM.getTargetData()->isLittleEndian();
 
   // Create the machine code emitter object for this target.
   MCE = new ELFCodeEmitter(*this);
@@ -242,8 +237,8 @@ void ELFWriter::EmitGlobal(GlobalVariable *GV) {
   }
 
   const Type *GVType = (const Type*)GV->getType();
-  unsigned Align = TM.getTargetData().getTypeAlignment(GVType);
-  unsigned Size  = TM.getTargetData().getTypeSize(GVType);
+  unsigned Align = TM.getTargetData()->getTypeAlignment(GVType);
+  unsigned Size  = TM.getTargetData()->getTypeSize(GVType);
 
   // If this global has a zero initializer, it is part of the .bss or common
   // section.
@@ -499,7 +494,7 @@ void ELFWriter::OutputSectionsAndSectionTable() {
     if (S.Align)
       for (size_t NewFileOff = (FileOff+S.Align-1) & ~(S.Align-1);
            FileOff != NewFileOff; ++FileOff)
-        O.put(0xAB);
+        O.put((char)0xAB);
     O.write((char*)&S.SectionData[0], S.SectionData.size());
     FileOff += S.SectionData.size();
 
@@ -520,7 +515,7 @@ void ELFWriter::OutputSectionsAndSectionTable() {
   // Align output for the section table.
   for (size_t NewFileOff = (FileOff+TableAlign-1) & ~(TableAlign-1);
        FileOff != NewFileOff; ++FileOff)
-    O.put(0xAB);
+    O.put((char)0xAB);
 
   // Emit the section table itself.
   O.write((char*)&Table[0], Table.size());