1 //===-- PPC32CodeEmitter.cpp - JIT Code Emitter for PowerPC32 -----*- C++ -*-=//
3 // The LLVM Compiler Infrastructure
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.
8 //===----------------------------------------------------------------------===//
10 // This file defines the PowerPC 32-bit CodeEmitter and associated machinery to
11 // JIT-compile bytecode to native PowerPC.
13 //===----------------------------------------------------------------------===//
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"
25 class PPC32CodeEmitter : public MachineFunctionPass {
27 MachineCodeEmitter &MCE;
29 int64_t getMachineOpValue(MachineInstr &MI, MachineOperand &MO);
32 PPC32CodeEmitter(TargetMachine &T, MachineCodeEmitter &M)
35 const char *getPassName() const { return "PowerPC Machine Code Emitter"; }
37 /// runOnMachineFunction - emits the given MachineFunction to memory
39 bool runOnMachineFunction(MachineFunction &MF);
41 /// emitBasicBlock - emits the given MachineBasicBlock to memory
43 void emitBasicBlock(MachineBasicBlock &MBB);
45 /// emitWord - write a 32-bit word to memory at the current PC
47 void emitWord(unsigned w) { MCE.emitWord(w); }
49 /// getValueBit - return the particular bit of Val
51 unsigned getValueBit(int64_t Val, unsigned bit) { return (Val >> bit) & 1; }
53 /// getBinaryCodeForInstr - returns the assembled code for an instruction
55 unsigned getBinaryCodeForInstr(MachineInstr &MI);
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
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());
74 bool PPC32CodeEmitter::runOnMachineFunction(MachineFunction &MF) {
75 MCE.startFunction(MF);
76 MCE.emitConstantPool(MF.getConstantPool());
77 for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I)
79 MCE.finishFunction(MF);
83 void PPC32CodeEmitter::emitBasicBlock(MachineBasicBlock &MBB) {
84 for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end(); I != E; ++I)
85 emitWord(getBinaryCodeForInstr(*I));
88 int64_t PPC32CodeEmitter::getMachineOpValue(MachineInstr &MI,
90 int64_t rv = 0; // Return value; defaults to 0 for unhandled cases
91 // or things that get fixed up later by the JIT.
92 if (MO.isPCRelativeDisp()) {
93 std::cerr << "PPC32CodeEmitter: PC-relative disp unhandled\n";
95 } else if (MO.isRegister()) {
97 } else if (MO.isImmediate()) {
98 rv = MO.getImmedValue();
100 } else if (MO.isGlobalAddress()) {
101 } else if (MO.isMachineBasicBlock()) {
102 MachineBasicBlock *MBB = MO.getMachineBasicBlock();
103 } else if (MO.isExternalSymbol()) {
104 } else if (MO.isFrameIndex()) {
105 unsigned index = MO.getFrameIndex();
106 } else if (MO.isConstantPoolIndex()) {
107 unsigned index = MO.getCosntantPoolIndex();
110 std::cerr << "ERROR: Unknown type of MachineOperand: " << MO << "\n";
118 void *PPC32JITInfo::getJITStubForFunction(Function *F,
119 MachineCodeEmitter &MCE) {
120 std::cerr << "PPC32JITInfo::getJITStubForFunction not implemented\n";
125 void PPC32JITInfo::replaceMachineCodeForFunction (void *Old, void *New) {
126 std::cerr << "PPC32JITInfo::replaceMachineCodeForFunction not implemented\n";
130 #include "PPC32GenCodeEmitter.inc"
132 } // end llvm namespace