X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=include%2Fllvm%2FCodeGen%2FMachineInstrBuilder.h;h=6ca63f01109eef2f7b467e344d90a1e6f402cf92;hb=e9a059714e3dccd6c870f19c3839f3352ac823ed;hp=c2944c0369630cdcfbf9b1085433a6afdbfa2b4f;hpb=ea50fabfd4e5fad25a25b312f64a9b2a53363586;p=oota-llvm.git diff --git a/include/llvm/CodeGen/MachineInstrBuilder.h b/include/llvm/CodeGen/MachineInstrBuilder.h index c2944c03696..6ca63f01109 100644 --- a/include/llvm/CodeGen/MachineInstrBuilder.h +++ b/include/llvm/CodeGen/MachineInstrBuilder.h @@ -2,19 +2,13 @@ // // 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 is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. // //===----------------------------------------------------------------------===// // // This file exposes a function named BuildMI, which is useful for dramatically -// simplifying how MachineInstr's are created. Instead of using code like this: -// -// M = new MachineInstr(X86::ADDrr8); -// M->SetMachineOperandVal(0, MachineOperand::MO_VirtualRegister, argVal1); -// M->SetMachineOperandVal(1, MachineOperand::MO_VirtualRegister, argVal2); -// -// we can now use code like this: +// simplifying how MachineInstr's are created. It allows use of code like this: // // M = BuildMI(X86::ADDrr8, 2).addReg(argVal1).addReg(argVal2); // @@ -23,14 +17,30 @@ #ifndef LLVM_CODEGEN_MACHINEINSTRBUILDER_H #define LLVM_CODEGEN_MACHINEINSTRBUILDER_H -#include "llvm/CodeGen/MachineBasicBlock.h" +#include "llvm/CodeGen/MachineFunction.h" namespace llvm { +class TargetInstrDesc; + +namespace RegState { + enum { + Define = 0x2, + Implicit = 0x4, + Kill = 0x8, + Dead = 0x10, + Undef = 0x20, + EarlyClobber = 0x40, + ImplicitDefine = Implicit | Define, + ImplicitKill = Implicit | Kill + }; +} + class MachineInstrBuilder { MachineInstr *MI; public: - MachineInstrBuilder(MachineInstr *mi) : MI(mi) {} + MachineInstrBuilder() : MI(0) {} + explicit MachineInstrBuilder(MachineInstr *mi) : MI(mi) {} /// Allow automatic conversion to the machine instruction we are working on. /// @@ -39,107 +49,114 @@ public: /// addReg - Add a new virtual register operand... /// - const MachineInstrBuilder &addReg( - int RegNo, - MachineOperand::UseType Ty = MachineOperand::Use) const { - MI->addRegOperand(RegNo, Ty); + const + MachineInstrBuilder &addReg(unsigned RegNo, unsigned flags = 0, + unsigned SubReg = 0) const { + assert((flags & 0x1) == 0 && + "Passing in 'true' to addReg is forbidden! Use enums instead."); + MI->addOperand(MachineOperand::CreateReg(RegNo, + flags & RegState::Define, + flags & RegState::Implicit, + flags & RegState::Kill, + flags & RegState::Dead, + flags & RegState::Undef, + flags & RegState::EarlyClobber, + SubReg)); return *this; } /// addImm - Add a new immediate operand. /// - const MachineInstrBuilder &addImm(int Val) const { - MI->addZeroExtImmOperand(Val); + const MachineInstrBuilder &addImm(int64_t Val) const { + MI->addOperand(MachineOperand::CreateImm(Val)); return *this; } - /// addSImm - Add a new sign extended immediate operand... - /// - const MachineInstrBuilder &addSImm(int val) const { - MI->addSignExtImmOperand(val); + const MachineInstrBuilder &addFPImm(const ConstantFP *Val) const { + MI->addOperand(MachineOperand::CreateFPImm(Val)); return *this; } - /// addZImm - Add a new zero extended immediate operand... - /// - const MachineInstrBuilder &addZImm(unsigned Val) const { - MI->addZeroExtImmOperand(Val); + const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB, + unsigned char TargetFlags = 0) const { + MI->addOperand(MachineOperand::CreateMBB(MBB, TargetFlags)); return *this; } - /// addImm64 - Add a new 64-bit immediate operand... - /// - const MachineInstrBuilder &addImm64(uint64_t Val) const { - MI->addZeroExtImm64Operand(Val); + const MachineInstrBuilder &addFrameIndex(unsigned Idx) const { + MI->addOperand(MachineOperand::CreateFI(Idx)); return *this; } - const MachineInstrBuilder &addMBB(MachineBasicBlock *MBB) const { - MI->addMachineBasicBlockOperand(MBB); + const MachineInstrBuilder &addConstantPoolIndex(unsigned Idx, + int Offset = 0, + unsigned char TargetFlags = 0) const { + MI->addOperand(MachineOperand::CreateCPI(Idx, Offset, TargetFlags)); return *this; } - const MachineInstrBuilder &addFrameIndex(unsigned Idx) const { - MI->addFrameIndexOperand(Idx); + const MachineInstrBuilder &addJumpTableIndex(unsigned Idx, + unsigned char TargetFlags = 0) const { + MI->addOperand(MachineOperand::CreateJTI(Idx, TargetFlags)); return *this; } - const MachineInstrBuilder &addConstantPoolIndex(unsigned Idx, - int Offset = 0) const { - MI->addConstantPoolIndexOperand(Idx, Offset); + const MachineInstrBuilder &addGlobalAddress(GlobalValue *GV, + int64_t Offset = 0, + unsigned char TargetFlags = 0) const { + MI->addOperand(MachineOperand::CreateGA(GV, Offset, TargetFlags)); return *this; } - const MachineInstrBuilder &addJumpTableIndex(unsigned Idx) const { - MI->addJumpTableIndexOperand(Idx); + const MachineInstrBuilder &addExternalSymbol(const char *FnName, + unsigned char TargetFlags = 0) const { + MI->addOperand(MachineOperand::CreateES(FnName, TargetFlags)); return *this; } - const MachineInstrBuilder &addGlobalAddress(GlobalValue *GV, - int Offset = 0) const { - MI->addGlobalAddressOperand(GV, Offset); + const MachineInstrBuilder &addMemOperand(MachineMemOperand *MMO) const { + MI->addMemOperand(*MI->getParent()->getParent(), MMO); return *this; } - const MachineInstrBuilder &addExternalSymbol(const char *FnName) const{ - MI->addExternalSymbolOperand(FnName); + const MachineInstrBuilder &addOperand(const MachineOperand &MO) const { + MI->addOperand(MO); return *this; } }; /// BuildMI - Builder interface. Specify how to create the initial instruction -/// itself. NumOperands is the number of operands to the machine instruction to -/// allow for memory efficient representation of machine instructions. +/// itself. /// -inline MachineInstrBuilder BuildMI(int Opcode, unsigned NumOperands) { - return MachineInstrBuilder(new MachineInstr(Opcode, NumOperands, true, true)); +inline MachineInstrBuilder BuildMI(MachineFunction &MF, + DebugLoc DL, + const TargetInstrDesc &TID) { + return MachineInstrBuilder(MF.CreateMachineInstr(TID, DL)); } /// BuildMI - This version of the builder sets up the first operand as a -/// destination virtual register. NumOperands is the number of additional add* -/// calls that are expected, not including the destination register. +/// destination virtual register. /// -inline MachineInstrBuilder BuildMI( - int Opcode, unsigned NumOperands, - unsigned DestReg, - MachineOperand::UseType useType = MachineOperand::Def) { - return MachineInstrBuilder(new MachineInstr(Opcode, NumOperands+1, - true, true)).addReg(DestReg, useType); +inline MachineInstrBuilder BuildMI(MachineFunction &MF, + DebugLoc DL, + const TargetInstrDesc &TID, + unsigned DestReg) { + return MachineInstrBuilder(MF.CreateMachineInstr(TID, DL)) + .addReg(DestReg, RegState::Define); } /// BuildMI - This version of the builder inserts the newly-built /// instruction before the given position in the given MachineBasicBlock, and /// sets up the first operand as a destination virtual register. -/// NumOperands is the number of additional add* calls that are expected, -/// not including the destination register. /// inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineBasicBlock::iterator I, - int Opcode, unsigned NumOperands, + DebugLoc DL, + const TargetInstrDesc &TID, unsigned DestReg) { - MachineInstr *MI = new MachineInstr(Opcode, NumOperands+1, true, true); + MachineInstr *MI = BB.getParent()->CreateMachineInstr(TID, DL); BB.insert(I, MI); - return MachineInstrBuilder(MI).addReg(DestReg, MachineOperand::Def); + return MachineInstrBuilder(MI).addReg(DestReg, RegState::Define); } /// BuildMI - This version of the builder inserts the newly-built @@ -148,8 +165,9 @@ inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, /// inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, MachineBasicBlock::iterator I, - int Opcode, unsigned NumOperands) { - MachineInstr *MI = new MachineInstr(Opcode, NumOperands, true, true); + DebugLoc DL, + const TargetInstrDesc &TID) { + MachineInstr *MI = BB.getParent()->CreateMachineInstr(TID, DL); BB.insert(I, MI); return MachineInstrBuilder(MI); } @@ -158,20 +176,37 @@ inline MachineInstrBuilder BuildMI(MachineBasicBlock &BB, /// instruction at the end of the given MachineBasicBlock, and does NOT take a /// destination register. /// -inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, int Opcode, - unsigned NumOperands) { - return BuildMI(*BB, BB->end(), Opcode, NumOperands); +inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, + DebugLoc DL, + const TargetInstrDesc &TID) { + return BuildMI(*BB, BB->end(), DL, TID); } /// BuildMI - This version of the builder inserts the newly-built /// instruction at the end of the given MachineBasicBlock, and sets up the first -/// operand as a destination virtual register. NumOperands is the number of -/// additional add* calls that are expected, not including the destination -/// register. +/// operand as a destination virtual register. /// -inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, int Opcode, - unsigned NumOperands, unsigned DestReg) { - return BuildMI(*BB, BB->end(), Opcode, NumOperands, DestReg); +inline MachineInstrBuilder BuildMI(MachineBasicBlock *BB, + DebugLoc DL, + const TargetInstrDesc &TID, + unsigned DestReg) { + return BuildMI(*BB, BB->end(), DL, TID, DestReg); +} + +inline unsigned getDefRegState(bool B) { + return B ? RegState::Define : 0; +} +inline unsigned getImplRegState(bool B) { + return B ? RegState::Implicit : 0; +} +inline unsigned getKillRegState(bool B) { + return B ? RegState::Kill : 0; +} +inline unsigned getDeadRegState(bool B) { + return B ? RegState::Dead : 0; +} +inline unsigned getUndefRegState(bool B) { + return B ? RegState::Undef : 0; } } // End llvm namespace