lib/Target/PowerPC/PPCCodeEmitter.cpp

   1 //===-- PPC32CodeEmitter.cpp - JIT Code Emitter for PowerPC32 -----*- C++ -*-=//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file was developed by the LLVM research group and is distributed under
   6 // the University of Illinois Open Source License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines the PowerPC 32-bit CodeEmitter and associated machinery to
  11 // JIT-compile bytecode to native PowerPC.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "PPC32JITInfo.h"
  16 #include "PPC32TargetMachine.h"
  17 #include "llvm/CodeGen/MachineCodeEmitter.h"
  18 #include "llvm/CodeGen/MachineFunctionPass.h"
  19 #include "llvm/CodeGen/Passes.h"
  20 #include "llvm/Support/Debug.h"
  21
  22 namespace llvm {
  23
  24 namespace {
  25   class PPC32CodeEmitter : public MachineFunctionPass {
  26     TargetMachine &TM;
  27     MachineCodeEmitter &MCE;
  28
  29     int64_t getMachineOpValue(MachineInstr &MI, MachineOperand &MO);
  30
  31   public:
  32     PPC32CodeEmitter(TargetMachine &T, MachineCodeEmitter &M)
  33       : TM(T), MCE(M) {}
  34
  35     const char *getPassName() const { return "PowerPC Machine Code Emitter"; }
  36
  37     /// runOnMachineFunction - emits the given MachineFunction to memory
  38     ///
  39     bool runOnMachineFunction(MachineFunction &MF);
  40
  41     /// emitBasicBlock - emits the given MachineBasicBlock to memory
  42     ///
  43     void emitBasicBlock(MachineBasicBlock &MBB);
  44
  45     /// emitWord - write a 32-bit word to memory at the current PC
  46     ///
  47     void emitWord(unsigned w) { MCE.emitWord(w); }
  48
  49     /// getValueBit - return the particular bit of Val
  50     ///
  51     unsigned getValueBit(int64_t Val, unsigned bit) { return (Val >> bit) & 1; }
  52
  53     /// getBinaryCodeForInstr - returns the assembled code for an instruction
  54     ///
  55     unsigned getBinaryCodeForInstr(MachineInstr &MI);
  56   };
  57 }
  58
  59 /// addPassesToEmitMachineCode - Add passes to the specified pass manager to get
  60 /// machine code emitted.  This uses a MachineCodeEmitter object to handle
  61 /// actually outputting the machine code and resolving things like the address
  62 /// of functions.  This method should returns true if machine code emission is
  63 /// not supported.
  64 ///
  65 bool PPC32TargetMachine::addPassesToEmitMachineCode(FunctionPassManager &PM,
  66                                                     MachineCodeEmitter &MCE) {
  67   // Machine code emitter pass for PowerPC
  68   PM.add(new PPC32CodeEmitter(*this, MCE));
  69   // Delete machine code for this function after emitting it
  70   PM.add(createMachineCodeDeleter());
  71   // We don't yet support machine code emission
  72   return true;
  73 }
  74
  75 bool PPC32CodeEmitter::runOnMachineFunction(MachineFunction &MF) {
  76   MCE.startFunction(MF);
  77   MCE.emitConstantPool(MF.getConstantPool());
  78   for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I)
  79     emitBasicBlock(*I);
  80   MCE.finishFunction(MF);
  81   return false;
  82 }
  83
  84 void PPC32CodeEmitter::emitBasicBlock(MachineBasicBlock &MBB) {
  85   for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end(); I != E; ++I)
  86     emitWord(getBinaryCodeForInstr(*I));
  87 }
  88
  89 int64_t PPC32CodeEmitter::getMachineOpValue(MachineInstr &MI,
  90                                             MachineOperand &MO) {
  91   abort();
  92   return 0;
  93 }
  94
  95
  96 void *PPC32JITInfo::getJITStubForFunction(Function *F,
  97                                           MachineCodeEmitter &MCE) {
  98   std::cerr << "PPC32JITInfo::getJITStubForFunction not implemented\n";
  99   abort();
 100   return 0;
 101 }
 102
 103 void PPC32JITInfo::replaceMachineCodeForFunction (void *Old, void *New) {
 104   std::cerr << "PPC32JITInfo::replaceMachineCodeForFunction not implemented\n";
 105   abort();
 106 }
 107
 108 #include "PPC32GenCodeEmitter.inc"
 109
 110 } // end llvm namespace
 111