1 //===-- X86FastISel.cpp - X86 FastISel implementation ---------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the X86-specific support for the FastISel class. Much
11 // of the target-specific code is generated by tablegen in the file
12 // X86GenFastISel.inc, which is #included here.
14 //===----------------------------------------------------------------------===//
17 #include "X86InstrBuilder.h"
18 #include "X86ISelLowering.h"
19 #include "X86RegisterInfo.h"
20 #include "X86Subtarget.h"
21 #include "X86TargetMachine.h"
22 #include "llvm/Instructions.h"
23 #include "llvm/DerivedTypes.h"
24 #include "llvm/CodeGen/FastISel.h"
25 #include "llvm/CodeGen/MachineConstantPool.h"
26 #include "llvm/CodeGen/MachineRegisterInfo.h"
30 class X86FastISel : public FastISel {
31 /// Subtarget - Keep a pointer to the X86Subtarget around so that we can
32 /// make the right decision when generating code for different targets.
33 const X86Subtarget *Subtarget;
36 explicit X86FastISel(MachineFunction &mf,
37 DenseMap<const Value *, unsigned> &vm,
38 DenseMap<const BasicBlock *, MachineBasicBlock *> &bm)
39 : FastISel(mf, vm, bm) {
40 Subtarget = &TM.getSubtarget<X86Subtarget>();
43 virtual bool TargetSelectInstruction(Instruction *I);
45 #include "X86GenFastISel.inc"
48 bool X86SelectConstAddr(Value *V, unsigned &Op0);
50 bool X86SelectLoad(Instruction *I);
52 bool X86SelectStore(Instruction *I);
54 bool X86SelectCmp(Instruction *I);
56 bool X86SelectZExt(Instruction *I);
58 bool X86SelectBranch(Instruction *I);
60 unsigned TargetSelectConstantPoolLoad(Constant *C, MachineConstantPool* MCP);
63 /// X86SelectConstAddr - Select and emit code to materialize constant address.
65 bool X86FastISel::X86SelectConstAddr(Value *V,
67 // FIXME: Only GlobalAddress for now.
68 GlobalValue *GV = dyn_cast<GlobalValue>(V);
72 if (Subtarget->GVRequiresExtraLoad(GV, TM, false)) {
73 // Issue load from stub if necessary.
75 const TargetRegisterClass *RC = NULL;
76 if (TLI.getPointerTy() == MVT::i32) {
78 RC = X86::GR32RegisterClass;
81 RC = X86::GR64RegisterClass;
83 Op0 = createResultReg(RC);
86 addFullAddress(BuildMI(MBB, TII.get(Opc), Op0), AM);
87 // Prevent loading GV stub multiple times in same MBB.
88 LocalValueMap[V] = Op0;
93 /// X86SelectStore - Select and emit code to implement store instructions.
94 bool X86FastISel::X86SelectStore(Instruction* I) {
95 MVT VT = MVT::getMVT(I->getOperand(0)->getType());
96 if (VT == MVT::Other || !VT.isSimple())
97 // Unhandled type. Halt "fast" selection and bail.
101 VT = TLI.getPointerTy();
102 // We only handle legal types. For example, on x86-32 the instruction
103 // selector contains all of the 64-bit instructions from x86-64,
104 // under the assumption that i64 won't be used if the target doesn't
106 if (!TLI.isTypeLegal(VT))
108 unsigned Op0 = getRegForValue(I->getOperand(0));
110 // Unhandled operand. Halt "fast" selection and bail.
113 Value *V = I->getOperand(1);
114 unsigned Op1 = getRegForValue(V);
116 // Handle constant load address.
117 if (!isa<Constant>(V) || !X86SelectConstAddr(V, Op1))
118 // Unhandled operand. Halt "fast" selection and bail.
122 // Get opcode and regclass of the output for the given load instruction.
124 const TargetRegisterClass *RC = NULL;
125 switch (VT.getSimpleVT()) {
126 default: return false;
129 RC = X86::GR8RegisterClass;
133 RC = X86::GR16RegisterClass;
137 RC = X86::GR32RegisterClass;
140 // Must be in x86-64 mode.
142 RC = X86::GR64RegisterClass;
145 if (Subtarget->hasSSE1()) {
147 RC = X86::FR32RegisterClass;
150 RC = X86::RFP32RegisterClass;
154 if (Subtarget->hasSSE2()) {
156 RC = X86::FR64RegisterClass;
159 RC = X86::RFP64RegisterClass;
164 RC = X86::RFP80RegisterClass;
170 // Address is in register.
173 AM.GV = cast<GlobalValue>(V);
174 addFullAddress(BuildMI(MBB, TII.get(Opc)), AM).addReg(Op0);
178 /// X86SelectLoad - Select and emit code to implement load instructions.
180 bool X86FastISel::X86SelectLoad(Instruction *I) {
181 MVT VT = MVT::getMVT(I->getType(), /*HandleUnknown=*/true);
182 if (VT == MVT::Other || !VT.isSimple())
183 // Unhandled type. Halt "fast" selection and bail.
187 VT = TLI.getPointerTy();
188 // We only handle legal types. For example, on x86-32 the instruction
189 // selector contains all of the 64-bit instructions from x86-64,
190 // under the assumption that i64 won't be used if the target doesn't
192 if (!TLI.isTypeLegal(VT))
195 Value *V = I->getOperand(0);
196 unsigned Op0 = getRegForValue(V);
198 // Handle constant load address.
199 if (!isa<Constant>(V) || !X86SelectConstAddr(V, Op0))
200 // Unhandled operand. Halt "fast" selection and bail.
204 // Get opcode and regclass of the output for the given load instruction.
206 const TargetRegisterClass *RC = NULL;
207 switch (VT.getSimpleVT()) {
208 default: return false;
211 RC = X86::GR8RegisterClass;
215 RC = X86::GR16RegisterClass;
219 RC = X86::GR32RegisterClass;
222 // Must be in x86-64 mode.
224 RC = X86::GR64RegisterClass;
227 if (Subtarget->hasSSE1()) {
229 RC = X86::FR32RegisterClass;
232 RC = X86::RFP32RegisterClass;
236 if (Subtarget->hasSSE2()) {
238 RC = X86::FR64RegisterClass;
241 RC = X86::RFP64RegisterClass;
246 RC = X86::RFP80RegisterClass;
250 unsigned ResultReg = createResultReg(RC);
253 // Address is in register.
256 AM.GV = cast<GlobalValue>(V);
257 addFullAddress(BuildMI(MBB, TII.get(Opc), ResultReg), AM);
258 UpdateValueMap(I, ResultReg);
262 bool X86FastISel::X86SelectCmp(Instruction *I) {
263 CmpInst *CI = cast<CmpInst>(I);
265 unsigned Op0Reg = getRegForValue(CI->getOperand(0));
266 unsigned Op1Reg = getRegForValue(CI->getOperand(1));
269 switch (TLI.getValueType(I->getOperand(0)->getType()).getSimpleVT()) {
270 case MVT::i8: Opc = X86::CMP8rr; break;
271 case MVT::i16: Opc = X86::CMP16rr; break;
272 case MVT::i32: Opc = X86::CMP32rr; break;
273 case MVT::i64: Opc = X86::CMP64rr; break;
274 case MVT::f32: Opc = X86::UCOMISSrr; break;
275 case MVT::f64: Opc = X86::UCOMISDrr; break;
276 default: return false;
279 unsigned ResultReg = createResultReg(&X86::GR8RegClass);
280 switch (CI->getPredicate()) {
281 case CmpInst::FCMP_OEQ: {
282 unsigned EReg = createResultReg(&X86::GR8RegClass);
283 unsigned NPReg = createResultReg(&X86::GR8RegClass);
284 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
285 BuildMI(MBB, TII.get(X86::SETEr), EReg);
286 BuildMI(MBB, TII.get(X86::SETNPr), NPReg);
287 BuildMI(MBB, TII.get(X86::AND8rr), ResultReg).addReg(NPReg).addReg(EReg);
290 case CmpInst::FCMP_UNE: {
291 unsigned NEReg = createResultReg(&X86::GR8RegClass);
292 unsigned PReg = createResultReg(&X86::GR8RegClass);
293 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
294 BuildMI(MBB, TII.get(X86::SETNEr), NEReg);
295 BuildMI(MBB, TII.get(X86::SETPr), PReg);
296 BuildMI(MBB, TII.get(X86::OR8rr), ResultReg).addReg(PReg).addReg(NEReg);
299 case CmpInst::FCMP_OGT:
300 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
301 BuildMI(MBB, TII.get(X86::SETAr), ResultReg);
303 case CmpInst::FCMP_OGE:
304 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
305 BuildMI(MBB, TII.get(X86::SETAEr), ResultReg);
307 case CmpInst::FCMP_OLT:
308 BuildMI(MBB, TII.get(Opc)).addReg(Op1Reg).addReg(Op0Reg);
309 BuildMI(MBB, TII.get(X86::SETAr), ResultReg);
311 case CmpInst::FCMP_OLE:
312 BuildMI(MBB, TII.get(Opc)).addReg(Op1Reg).addReg(Op0Reg);
313 BuildMI(MBB, TII.get(X86::SETAEr), ResultReg);
315 case CmpInst::FCMP_ONE:
316 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
317 BuildMI(MBB, TII.get(X86::SETNEr), ResultReg);
319 case CmpInst::FCMP_ORD:
320 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
321 BuildMI(MBB, TII.get(X86::SETNPr), ResultReg);
323 case CmpInst::FCMP_UNO:
324 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
325 BuildMI(MBB, TII.get(X86::SETPr), ResultReg);
327 case CmpInst::FCMP_UEQ:
328 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
329 BuildMI(MBB, TII.get(X86::SETEr), ResultReg);
331 case CmpInst::FCMP_UGT:
332 BuildMI(MBB, TII.get(Opc)).addReg(Op1Reg).addReg(Op0Reg);
333 BuildMI(MBB, TII.get(X86::SETBr), ResultReg);
335 case CmpInst::FCMP_UGE:
336 BuildMI(MBB, TII.get(Opc)).addReg(Op1Reg).addReg(Op0Reg);
337 BuildMI(MBB, TII.get(X86::SETBEr), ResultReg);
339 case CmpInst::FCMP_ULT:
340 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
341 BuildMI(MBB, TII.get(X86::SETBr), ResultReg);
343 case CmpInst::FCMP_ULE:
344 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
345 BuildMI(MBB, TII.get(X86::SETBEr), ResultReg);
347 case CmpInst::ICMP_EQ:
348 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
349 BuildMI(MBB, TII.get(X86::SETEr), ResultReg);
351 case CmpInst::ICMP_NE:
352 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
353 BuildMI(MBB, TII.get(X86::SETNEr), ResultReg);
355 case CmpInst::ICMP_UGT:
356 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
357 BuildMI(MBB, TII.get(X86::SETAr), ResultReg);
359 case CmpInst::ICMP_UGE:
360 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
361 BuildMI(MBB, TII.get(X86::SETAEr), ResultReg);
363 case CmpInst::ICMP_ULT:
364 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
365 BuildMI(MBB, TII.get(X86::SETBr), ResultReg);
367 case CmpInst::ICMP_ULE:
368 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
369 BuildMI(MBB, TII.get(X86::SETBEr), ResultReg);
371 case CmpInst::ICMP_SGT:
372 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
373 BuildMI(MBB, TII.get(X86::SETGr), ResultReg);
375 case CmpInst::ICMP_SGE:
376 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
377 BuildMI(MBB, TII.get(X86::SETGEr), ResultReg);
379 case CmpInst::ICMP_SLT:
380 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
381 BuildMI(MBB, TII.get(X86::SETLr), ResultReg);
383 case CmpInst::ICMP_SLE:
384 BuildMI(MBB, TII.get(Opc)).addReg(Op0Reg).addReg(Op1Reg);
385 BuildMI(MBB, TII.get(X86::SETLEr), ResultReg);
391 UpdateValueMap(I, ResultReg);
395 bool X86FastISel::X86SelectZExt(Instruction *I) {
396 // Special-case hack: The only i1 values we know how to produce currently
397 // set the upper bits of an i8 value to zero.
398 if (I->getType() == Type::Int8Ty &&
399 I->getOperand(0)->getType() == Type::Int1Ty) {
400 unsigned ResultReg = getRegForValue(I->getOperand(0));
401 UpdateValueMap(I, ResultReg);
408 bool X86FastISel::X86SelectBranch(Instruction *I) {
409 BranchInst *BI = cast<BranchInst>(I);
410 // Unconditional branches are selected by tablegen-generated code.
411 unsigned OpReg = getRegForValue(BI->getCondition());
412 MachineBasicBlock *TrueMBB = MBBMap[BI->getSuccessor(0)];
413 MachineBasicBlock *FalseMBB = MBBMap[BI->getSuccessor(1)];
415 BuildMI(MBB, TII.get(X86::TEST8rr)).addReg(OpReg).addReg(OpReg);
416 BuildMI(MBB, TII.get(X86::JNE)).addMBB(TrueMBB);
417 BuildMI(MBB, TII.get(X86::JMP)).addMBB(FalseMBB);
419 MBB->addSuccessor(TrueMBB);
420 MBB->addSuccessor(FalseMBB);
426 X86FastISel::TargetSelectInstruction(Instruction *I) {
427 switch (I->getOpcode()) {
429 case Instruction::Load:
430 return X86SelectLoad(I);
431 case Instruction::Store:
432 return X86SelectStore(I);
433 case Instruction::ICmp:
434 case Instruction::FCmp:
435 return X86SelectCmp(I);
436 case Instruction::ZExt:
437 return X86SelectZExt(I);
438 case Instruction::Br:
439 return X86SelectBranch(I);
445 unsigned X86FastISel::TargetSelectConstantPoolLoad(Constant *C,
446 MachineConstantPool* MCP) {
447 unsigned CPLoad = getRegForValue(C);
451 // Can't handle PIC-mode yet.
452 if (TM.getRelocationModel() == Reloc::PIC_)
455 MVT VT = MVT::getMVT(C->getType(), /*HandleUnknown=*/true);
456 if (VT == MVT::Other || !VT.isSimple())
457 // Unhandled type. Halt "fast" selection and bail.
461 VT = TLI.getPointerTy();
462 // We only handle legal types. For example, on x86-32 the instruction
463 // selector contains all of the 64-bit instructions from x86-64,
464 // under the assumption that i64 won't be used if the target doesn't
466 if (!TLI.isTypeLegal(VT))
469 // Get opcode and regclass of the output for the given load instruction.
471 const TargetRegisterClass *RC = NULL;
472 switch (VT.getSimpleVT()) {
473 default: return false;
476 RC = X86::GR8RegisterClass;
480 RC = X86::GR16RegisterClass;
484 RC = X86::GR32RegisterClass;
487 // Must be in x86-64 mode.
489 RC = X86::GR64RegisterClass;
492 if (Subtarget->hasSSE1()) {
494 RC = X86::FR32RegisterClass;
497 RC = X86::RFP32RegisterClass;
501 if (Subtarget->hasSSE2()) {
503 RC = X86::FR64RegisterClass;
506 RC = X86::RFP64RegisterClass;
511 RC = X86::RFP80RegisterClass;
515 unsigned ResultReg = createResultReg(RC);
516 if (isa<GlobalValue>(C)) {
517 if (X86SelectConstAddr(C, ResultReg))
524 unsigned MCPOffset = MCP->getConstantPoolIndex(C, 0);
525 addConstantPoolReference(BuildMI(MBB, TII.get(Opc), ResultReg), MCPOffset);
526 UpdateValueMap(C, ResultReg);
531 llvm::FastISel *X86::createFastISel(MachineFunction &mf,
532 DenseMap<const Value *, unsigned> &vm,
533 DenseMap<const BasicBlock *, MachineBasicBlock *> &bm) {
534 return new X86FastISel(mf, vm, bm);