Alpha doesn't have a native f32 extload instruction.

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

diff --git a/lib/CodeGen/MachineCodeEmitter.cpp b/lib/CodeGen/MachineCodeEmitter.cpp
index d91efe2cc1b5bcf8d99c5815410e3006876c9a00..248b06a999bc5c52692bda76c3a00648f8a41fce 100644 (file)
--- a/lib/CodeGen/MachineCodeEmitter.cpp
+++ b/lib/CodeGen/MachineCodeEmitter.cpp
@@ -1,4 +1,11 @@
 //===-- MachineCodeEmitter.cpp - Implement the MachineCodeEmitter itf -----===//
+// 
+//                     The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+// 
+//===----------------------------------------------------------------------===//
 //
 // This file implements the MachineCodeEmitter interface.
 //
@@ -7,8 +14,11 @@
 #include "llvm/CodeGen/MachineCodeEmitter.h"
 #include "llvm/CodeGen/MachineFunction.h"
 #include "llvm/Function.h"
+#include <fstream>
 #include <iostream>
 
+using namespace llvm;
+
 namespace {
   struct DebugMachineCodeEmitter : public MachineCodeEmitter {
     void startFunction(MachineFunction &F) {
@@ -18,44 +28,142 @@ namespace {
     void finishFunction(MachineFunction &F) {
       std::cout << "\n";
     }
-    void startBasicBlock(MachineBasicBlock &BB) {
-      std::cout << "\n--- Basic Block: " << BB.getBasicBlock()->getName()<<"\n";
+    void startFunctionStub(unsigned StubSize) {
+      std::cout << "\n--- Function stub:\n";
     }
-
-    void startFunctionStub(const Function &F, unsigned StubSize) {
-      std::cout << "\n--- Function stub for function: " << F.getName() << "\n";
-    }
-    void *finishFunctionStub(const Function &F) {
-      std::cout << "\n";
+    void *finishFunctionStub(const Function *F) {
+      std::cout << "\n--- End of stub for Function\n";
       return 0;
     }
     
     void emitByte(unsigned char B) {
       std::cout << "0x" << std::hex << (unsigned int)B << std::dec << " ";
     }
-    void emitPCRelativeDisp(Value *V) {
-      std::cout << "<disp %" << V->getName() << ": 0xXX 0xXX 0xXX 0xXX> ";
+    void emitWord(unsigned W) {
+      std::cout << "0x" << std::hex << W << std::dec << " ";
+    }
+    void emitWordAt(unsigned W, unsigned *Ptr) {
+      std::cout << "0x" << std::hex << W << std::dec << " (at "
+                << (void*) Ptr << ") ";
+    }
+
+    void addRelocation(const MachineRelocation &MR) {
+      std::cout << "<relocation> ";
+    }
+
+    uint64_t getConstantPoolEntryAddress(unsigned Num) { return 0; }
+    uint64_t getCurrentPCValue() { return 0; }
+    uint64_t getCurrentPCOffset() { return 0; }
+  };
+
+  class FilePrinterEmitter : public MachineCodeEmitter {
+    std::ofstream actual;
+    std::ostream &o;
+    MachineCodeEmitter &MCE;
+    unsigned counter;
+    unsigned values[4];
+    
+  public:
+    FilePrinterEmitter(MachineCodeEmitter &M, std::ostream &os)
+      : o(os), MCE(M), counter(0) {
+      openActual();
+    }
+    
+    ~FilePrinterEmitter() { 
+      o << "\n";
+      actual.close();
     }
-    void emitGlobalAddress(GlobalValue *V, bool isPCRelative) {
-      std::cout << "<addr %" << V->getName() << ": 0xXX 0xXX 0xXX 0xXX> ";
+
+    void openActual() {
+      actual.open("lli.actual.obj");
+      if (!actual.good()) {
+        std::cerr << "Cannot open 'lli.actual.obj' for writing\n";
+        abort();
+      }
     }
-    void emitGlobalAddress(const std::string &Name, bool isPCRelative) {
-      std::cout << "<addr %" << Name << ": 0xXX 0xXX 0xXX 0xXX> ";
+
+    void startFunction(MachineFunction &F) {
+      // resolve any outstanding calls
+      MCE.startFunction(F);
+    }
+    void finishFunction(MachineFunction &F) {
+      MCE.finishFunction(F);
     }
 
-    void emitFunctionConstantValueAddress(unsigned ConstantNum, int Offset) {
-      std::cout << "<addr const#" << ConstantNum;
-      if (Offset) std::cout << " + " << Offset;
-      std::cout << "> ";
+    void emitConstantPool(MachineConstantPool *MCP) {
+      MCE.emitConstantPool(MCP);
+    }
+
+    void startFunctionStub(unsigned StubSize) {
+      MCE.startFunctionStub(StubSize);
+    }
+
+    void *finishFunctionStub(const Function *F) {
+      return MCE.finishFunctionStub(F);
+    }
+    
+    void emitByte(unsigned char B) {
+      MCE.emitByte(B);
+      actual << B; actual.flush();
+
+      values[counter] = (unsigned int) B;
+      if (++counter % 4 == 0 && counter != 0) {
+        o << std::hex;
+        for (unsigned i=0; i<4; ++i) {
+          if (values[i] < 16) o << "0";
+          o << values[i] << " ";
+        }
+
+        o << std::dec << "\t";
+        for (unsigned i=0; i<4; ++i) {
+          for (int j=7; j>=0; --j) {
+            o << ((values[i] >> j) & 1);
+          }
+          o << " ";
+        }
+
+        o << "\n";
+
+        unsigned instr = 0;
+        for (unsigned i=0; i<4; ++i)
+          instr |= values[i] << (i*8);
+
+        o << "--- * --- * --- * --- * ---\n";
+        counter %= 4;
+      }
+    }
+
+    void emitWord(unsigned W) {
+      MCE.emitWord(W);
+    }
+    void emitWordAt(unsigned W, unsigned *Ptr) {
+      MCE.emitWordAt(W, Ptr);
+    }
+    uint64_t getConstantPoolEntryAddress(unsigned Num) {
+      return MCE.getConstantPoolEntryAddress(Num);
+    }
+    uint64_t getCurrentPCValue() {
+      return MCE.getCurrentPCValue();
+    }
+    uint64_t getCurrentPCOffset() {
+      return MCE.getCurrentPCOffset();
+    }
+    void addRelocation(const MachineRelocation &MR) {
+      return MCE.addRelocation(MR);
     }
   };
 }
 
-
 /// createDebugMachineCodeEmitter - Return a dynamically allocated machine
 /// code emitter, which just prints the opcodes and fields out the cout.  This
 /// can be used for debugging users of the MachineCodeEmitter interface.
 ///
-MachineCodeEmitter *MachineCodeEmitter::createDebugMachineCodeEmitter() {
+MachineCodeEmitter *
+MachineCodeEmitter::createDebugEmitter() {
   return new DebugMachineCodeEmitter();
 }
+
+MachineCodeEmitter *
+MachineCodeEmitter::createFilePrinterEmitter(MachineCodeEmitter &MCE) {
+  return new FilePrinterEmitter(MCE, std::cerr);
+}