blob: 6e3d68d0477a28848148e38686e9978c685c75d8 [file] [log] [blame]
Nate Begeman6cca84e2005-10-16 05:39:50 +00001//===-- PPCCodeEmitter.cpp - JIT Code Emitter for PowerPC32 -------*- C++ -*-=//
Misha Brukmanb4402432005-04-21 23:30:14 +00002//
Misha Brukmane05203f2004-06-21 16:55:25 +00003// 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.
Misha Brukmanb4402432005-04-21 23:30:14 +00007//
Misha Brukmane05203f2004-06-21 16:55:25 +00008//===----------------------------------------------------------------------===//
Misha Brukmanb4402432005-04-21 23:30:14 +00009//
Misha Brukman8b1bf432004-10-14 06:07:25 +000010// This file defines the PowerPC 32-bit CodeEmitter and associated machinery to
11// JIT-compile bytecode to native PowerPC.
Misha Brukmane05203f2004-06-21 16:55:25 +000012//
13//===----------------------------------------------------------------------===//
14
Chris Lattner6f3b9542005-10-14 23:59:06 +000015#include "PPCTargetMachine.h"
16#include "PPCRelocations.h"
Chris Lattnerbfca1ab2005-10-14 23:51:18 +000017#include "PPC.h"
Misha Brukman2beb63a2004-10-21 01:42:02 +000018#include "llvm/Module.h"
Chris Lattner03354282005-10-15 21:58:54 +000019#include "llvm/PassManager.h"
Misha Brukman18922912004-08-09 23:03:59 +000020#include "llvm/CodeGen/MachineCodeEmitter.h"
21#include "llvm/CodeGen/MachineFunctionPass.h"
Misha Brukman9ce0da92004-10-23 23:47:34 +000022#include "llvm/CodeGen/MachineInstrBuilder.h"
Misha Brukman18922912004-08-09 23:03:59 +000023#include "llvm/CodeGen/Passes.h"
Nate Begeman3cb39212006-08-23 21:08:52 +000024#include "llvm/Support/Debug.h"
Chris Lattner3d27be12006-08-27 12:54:02 +000025#include "llvm/Support/Compiler.h"
Evan Cheng5f997602006-02-18 00:08:58 +000026#include "llvm/Target/TargetOptions.h"
Chris Lattnerf2429792004-11-16 04:47:33 +000027using namespace llvm;
Misha Brukmane05203f2004-06-21 16:55:25 +000028
Misha Brukman18922912004-08-09 23:03:59 +000029namespace {
Chris Lattner996795b2006-06-28 23:17:24 +000030 class VISIBILITY_HIDDEN PPCCodeEmitter : public MachineFunctionPass {
Misha Brukman18922912004-08-09 23:03:59 +000031 TargetMachine &TM;
32 MachineCodeEmitter &MCE;
33
Chris Lattner09fecf92006-12-08 04:54:03 +000034 /// MovePCtoLROffset - When/if we see a MovePCtoLR instruction, we record
35 /// its address in the function into this pointer.
36 void *MovePCtoLROffset;
37
Misha Brukman2beb63a2004-10-21 01:42:02 +000038 /// getMachineOpValue - evaluates the MachineOperand of a given MachineInstr
39 ///
Chris Lattner743a4342004-11-23 05:59:53 +000040 int getMachineOpValue(MachineInstr &MI, MachineOperand &MO);
Misha Brukman2beb63a2004-10-21 01:42:02 +000041
Misha Brukman18922912004-08-09 23:03:59 +000042 public:
Chris Lattner0921e3b2005-10-14 23:37:35 +000043 PPCCodeEmitter(TargetMachine &T, MachineCodeEmitter &M)
Misha Brukman18922912004-08-09 23:03:59 +000044 : TM(T), MCE(M) {}
45
46 const char *getPassName() const { return "PowerPC Machine Code Emitter"; }
47
48 /// runOnMachineFunction - emits the given MachineFunction to memory
49 ///
50 bool runOnMachineFunction(MachineFunction &MF);
51
52 /// emitBasicBlock - emits the given MachineBasicBlock to memory
53 ///
54 void emitBasicBlock(MachineBasicBlock &MBB);
55
Misha Brukman8b1bf432004-10-14 06:07:25 +000056 /// getValueBit - return the particular bit of Val
57 ///
58 unsigned getValueBit(int64_t Val, unsigned bit) { return (Val >> bit) & 1; }
Misha Brukman18922912004-08-09 23:03:59 +000059
Misha Brukman2beb63a2004-10-21 01:42:02 +000060 /// getBinaryCodeForInstr - This function, generated by the
61 /// CodeEmitterGenerator using TableGen, produces the binary encoding for
62 /// machine instructions.
Misha Brukman18922912004-08-09 23:03:59 +000063 ///
Misha Brukman8b1bf432004-10-14 06:07:25 +000064 unsigned getBinaryCodeForInstr(MachineInstr &MI);
Misha Brukman18922912004-08-09 23:03:59 +000065 };
66}
67
Nate Begeman3cb39212006-08-23 21:08:52 +000068/// createPPCCodeEmitterPass - Return a pass that emits the collected PPC code
69/// to the specified MCE object.
70FunctionPass *llvm::createPPCCodeEmitterPass(PPCTargetMachine &TM,
71 MachineCodeEmitter &MCE) {
72 return new PPCCodeEmitter(TM, MCE);
Misha Brukman18922912004-08-09 23:03:59 +000073}
74
Evan Chengf6acb342006-07-25 20:40:54 +000075#ifdef __APPLE__
76extern "C" void sys_icache_invalidate(const void *Addr, size_t len);
77#endif
78
Chris Lattner0921e3b2005-10-14 23:37:35 +000079bool PPCCodeEmitter::runOnMachineFunction(MachineFunction &MF) {
Evan Cheng73136df2006-02-22 20:19:42 +000080 assert((MF.getTarget().getRelocationModel() != Reloc::Default ||
81 MF.getTarget().getRelocationModel() != Reloc::Static) &&
82 "JIT relocation model must be set to static or default!");
Chris Lattnerc9aa3712006-05-02 18:27:26 +000083 do {
Chris Lattner09fecf92006-12-08 04:54:03 +000084 MovePCtoLROffset = 0;
Chris Lattnerc9aa3712006-05-02 18:27:26 +000085 MCE.startFunction(MF);
Chris Lattnerc9aa3712006-05-02 18:27:26 +000086 for (MachineFunction::iterator BB = MF.begin(), E = MF.end(); BB != E; ++BB)
87 emitBasicBlock(*BB);
Chris Lattnerc9aa3712006-05-02 18:27:26 +000088 } while (MCE.finishFunction(MF));
Misha Brukman2beb63a2004-10-21 01:42:02 +000089
Misha Brukman18922912004-08-09 23:03:59 +000090 return false;
91}
92
Chris Lattner0921e3b2005-10-14 23:37:35 +000093void PPCCodeEmitter::emitBasicBlock(MachineBasicBlock &MBB) {
Chris Lattner1d8ee1f2006-05-03 17:10:41 +000094 MCE.StartMachineBasicBlock(&MBB);
95
Misha Brukman421c3c12004-10-23 18:28:01 +000096 for (MachineBasicBlock::iterator I = MBB.begin(), E = MBB.end(); I != E; ++I){
97 MachineInstr &MI = *I;
Chris Lattner743a4342004-11-23 05:59:53 +000098 switch (MI.getOpcode()) {
99 default:
Chris Lattnere1c96362006-05-02 19:14:47 +0000100 MCE.emitWordBE(getBinaryCodeForInstr(*I));
Chris Lattner743a4342004-11-23 05:59:53 +0000101 break;
Chris Lattnerd48ce272006-06-27 18:18:41 +0000102 case PPC::IMPLICIT_DEF_GPRC:
103 case PPC::IMPLICIT_DEF_G8RC:
Chris Lattnerd3eee1a2005-10-01 01:35:02 +0000104 case PPC::IMPLICIT_DEF_F8:
105 case PPC::IMPLICIT_DEF_F4:
Chris Lattner3a2ae6a2006-03-21 20:19:37 +0000106 case PPC::IMPLICIT_DEF_VRRC:
Chris Lattner743a4342004-11-23 05:59:53 +0000107 break; // pseudo opcode, no side effects
108 case PPC::MovePCtoLR:
Chris Lattner44dbdbe2006-11-14 18:44:47 +0000109 case PPC::MovePCtoLR8:
Chris Lattner09fecf92006-12-08 04:54:03 +0000110 assert(TM.getRelocationModel() == Reloc::PIC_);
111 MovePCtoLROffset = (void*)MCE.getCurrentPCValue();
112 MCE.emitWordBE(0x48000005); // bl 1
Chris Lattner743a4342004-11-23 05:59:53 +0000113 break;
114 }
Misha Brukman421c3c12004-10-23 18:28:01 +0000115 }
Misha Brukman18922912004-08-09 23:03:59 +0000116}
117
Chris Lattner0921e3b2005-10-14 23:37:35 +0000118int PPCCodeEmitter::getMachineOpValue(MachineInstr &MI, MachineOperand &MO) {
Misha Brukmanb4402432005-04-21 23:30:14 +0000119
Chris Lattner1d8ee1f2006-05-03 17:10:41 +0000120 intptr_t rv = 0; // Return value; defaults to 0 for unhandled cases
121 // or things that get fixed up later by the JIT.
Misha Brukman2beb63a2004-10-21 01:42:02 +0000122 if (MO.isRegister()) {
Chris Lattner6df094b2006-04-17 21:07:20 +0000123 rv = PPCRegisterInfo::getRegisterNumbering(MO.getReg());
Chris Lattner53c40622005-04-19 05:41:52 +0000124
Nate Begeman8465fe82005-07-20 22:42:00 +0000125 // Special encoding for MTCRF and MFOCRF, which uses a bit mask for the
Chris Lattner53c40622005-04-19 05:41:52 +0000126 // register, not the register number directly.
Nate Begeman8465fe82005-07-20 22:42:00 +0000127 if ((MI.getOpcode() == PPC::MTCRF || MI.getOpcode() == PPC::MFOCRF) &&
Chris Lattner53c40622005-04-19 05:41:52 +0000128 (MO.getReg() >= PPC::CR0 && MO.getReg() <= PPC::CR7)) {
129 rv = 0x80 >> rv;
130 }
Misha Brukman1f596c32004-10-14 06:39:56 +0000131 } else if (MO.isImmediate()) {
132 rv = MO.getImmedValue();
Nate Begeman3cb39212006-08-23 21:08:52 +0000133 } else if (MO.isGlobalAddress() || MO.isExternalSymbol() ||
134 MO.isConstantPoolIndex() || MO.isJumpTableIndex()) {
Chris Lattnerb1fd07a2004-11-23 15:56:38 +0000135 unsigned Reloc = 0;
Chris Lattner43df5b32007-02-25 05:34:32 +0000136 if (MI.getOpcode() == PPC::BL_Macho || MI.getOpcode() == PPC::BL8_Macho ||
137 MI.getOpcode() == PPC::BL_ELF || MI.getOpcode() == PPC::BL8_ELF)
Chris Lattner743a4342004-11-23 05:59:53 +0000138 Reloc = PPC::reloc_pcrel_bx;
Chris Lattnerdd516792004-11-24 22:30:08 +0000139 else {
Chris Lattner09fecf92006-12-08 04:54:03 +0000140 if (TM.getRelocationModel() == Reloc::PIC_) {
141 assert(MovePCtoLROffset && "MovePCtoLR not seen yet?");
Chris Lattner09fecf92006-12-08 04:54:03 +0000142 }
Nate Begemana9443f22005-07-21 20:44:43 +0000143 switch (MI.getOpcode()) {
Chris Lattner1fa392d2006-12-06 19:40:04 +0000144 default: MI.dump(); assert(0 && "Unknown instruction for relocation!");
Nate Begemana9443f22005-07-21 20:44:43 +0000145 case PPC::LIS:
Chris Lattner5b17dee2006-07-12 21:23:20 +0000146 case PPC::LIS8:
Nate Begeman3cb39212006-08-23 21:08:52 +0000147 case PPC::ADDIS:
Chris Lattner5b17dee2006-07-12 21:23:20 +0000148 case PPC::ADDIS8:
Nate Begeman516b39392006-04-21 22:04:15 +0000149 Reloc = PPC::reloc_absolute_high; // Pointer to symbol
Nate Begemana9443f22005-07-21 20:44:43 +0000150 break;
Chris Lattnerc8afdfe2006-04-22 06:17:56 +0000151 case PPC::LI:
Chris Lattner5b17dee2006-07-12 21:23:20 +0000152 case PPC::LI8:
Nate Begemana9443f22005-07-21 20:44:43 +0000153 case PPC::LA:
Chris Lattner5b17dee2006-07-12 21:23:20 +0000154 // Loads.
Nate Begemana9443f22005-07-21 20:44:43 +0000155 case PPC::LBZ:
Jim Laskeyb0367c92006-12-15 16:44:10 +0000156 case PPC::LBZ8:
Nate Begemana9443f22005-07-21 20:44:43 +0000157 case PPC::LHA:
Jim Laskeyb0367c92006-12-15 16:44:10 +0000158 case PPC::LHA8:
Nate Begemana9443f22005-07-21 20:44:43 +0000159 case PPC::LHZ:
Jim Laskeyb0367c92006-12-15 16:44:10 +0000160 case PPC::LHZ8:
Nate Begemana9443f22005-07-21 20:44:43 +0000161 case PPC::LWZ:
Jim Laskeyb0367c92006-12-15 16:44:10 +0000162 case PPC::LWZ8:
Nate Begemana9443f22005-07-21 20:44:43 +0000163 case PPC::LFS:
164 case PPC::LFD:
Chris Lattner5b17dee2006-07-12 21:23:20 +0000165
166 // Stores.
Nate Begemana9443f22005-07-21 20:44:43 +0000167 case PPC::STB:
Jim Laskeyb0367c92006-12-15 16:44:10 +0000168 case PPC::STB8:
Nate Begemana9443f22005-07-21 20:44:43 +0000169 case PPC::STH:
Jim Laskeyb0367c92006-12-15 16:44:10 +0000170 case PPC::STH8:
Nate Begemana9443f22005-07-21 20:44:43 +0000171 case PPC::STW:
Jim Laskeyb0367c92006-12-15 16:44:10 +0000172 case PPC::STW8:
Nate Begemana9443f22005-07-21 20:44:43 +0000173 case PPC::STFS:
174 case PPC::STFD:
Nate Begeman516b39392006-04-21 22:04:15 +0000175 Reloc = PPC::reloc_absolute_low;
Nate Begemana9443f22005-07-21 20:44:43 +0000176 break;
Chris Lattner5b17dee2006-07-12 21:23:20 +0000177
178 case PPC::LWA:
179 case PPC::LD:
180 case PPC::STD:
181 case PPC::STD_32:
182 Reloc = PPC::reloc_absolute_low_ix;
183 break;
Chris Lattnerdd516792004-11-24 22:30:08 +0000184 }
Chris Lattner743a4342004-11-23 05:59:53 +0000185 }
Chris Lattnerf4646a72006-12-11 23:22:45 +0000186
187 MachineRelocation R;
188 if (MO.isGlobalAddress()) {
189 R = MachineRelocation::getGV(MCE.getCurrentPCOffset(), Reloc,
190 MO.getGlobal(), 0);
191 } else if (MO.isExternalSymbol()) {
192 R = MachineRelocation::getExtSym(MCE.getCurrentPCOffset(),
193 Reloc, MO.getSymbolName(), 0);
194 } else if (MO.isConstantPoolIndex()) {
195 R = MachineRelocation::getConstPool(MCE.getCurrentPCOffset(),
196 Reloc, MO.getConstantPoolIndex(), 0);
197 } else {
198 assert(MO.isJumpTableIndex());
199 R = MachineRelocation::getJumpTable(MCE.getCurrentPCOffset(),
200 Reloc, MO.getJumpTableIndex(), 0);
201 }
202
203 // If in PIC mode, we need to encode the negated address of the
204 // 'movepctolr' into the unrelocated field. After relocation, we'll have
205 // &gv-&movepctolr-4 in the imm field. Once &movepctolr is added to the imm
206 // field, we get &gv. This doesn't happen for branch relocations, which are
207 // always implicitly pc relative.
208 if (TM.getRelocationModel() == Reloc::PIC_ && Reloc != PPC::reloc_pcrel_bx){
209 assert(MovePCtoLROffset && "MovePCtoLR not seen yet?");
210 R.setConstantVal(-(intptr_t)MovePCtoLROffset - 4);
211 }
212 MCE.addRelocation(R);
213
Misha Brukman1f596c32004-10-14 06:39:56 +0000214 } else if (MO.isMachineBasicBlock()) {
Evan Cheng78bf1072006-07-27 18:21:10 +0000215 unsigned Reloc = 0;
216 unsigned Opcode = MI.getOpcode();
Chris Lattner43df5b32007-02-25 05:34:32 +0000217 if (Opcode == PPC::B || Opcode == PPC::BL_Macho ||
218 Opcode == PPC::BLA_Macho || Opcode == PPC::BL_ELF ||
219 Opcode == PPC::BLA_ELF)
Evan Cheng78bf1072006-07-27 18:21:10 +0000220 Reloc = PPC::reloc_pcrel_bx;
Chris Lattner09fecf92006-12-08 04:54:03 +0000221 else // BCC instruction
Evan Cheng78bf1072006-07-27 18:21:10 +0000222 Reloc = PPC::reloc_pcrel_bcx;
223 MCE.addRelocation(MachineRelocation::getBB(MCE.getCurrentPCOffset(),
224 Reloc,
225 MO.getMachineBasicBlock()));
Chris Lattner6a7ebe02004-11-24 01:56:12 +0000226 } else {
Bill Wendling9bfb1e12006-12-07 22:21:48 +0000227 cerr << "ERROR: Unknown type of MachineOperand: " << MO << "\n";
Chris Lattner6a7ebe02004-11-24 01:56:12 +0000228 abort();
Misha Brukman421c3c12004-10-23 18:28:01 +0000229 }
Chris Lattner6a7ebe02004-11-24 01:56:12 +0000230
Misha Brukman1f596c32004-10-14 06:39:56 +0000231 return rv;
Misha Brukmane05203f2004-06-21 16:55:25 +0000232}
233
Chris Lattner0921e3b2005-10-14 23:37:35 +0000234#include "PPCGenCodeEmitter.inc"
Misha Brukman18922912004-08-09 23:03:59 +0000235