1 //===-- llvm/Support/LLVMBuilder.h - Builder for LLVM Instrs ----*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file was developed by Chris Lattner and is distributed under the
6 // University of Illinois Open Source License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This file defines the LLVMBuilder class, which is used as a convenient way
11 // to create LLVM instructions with a consistent and simplified interface.
13 //===----------------------------------------------------------------------===//
15 #ifndef LLVM_SUPPORT_LLVMBUILDER_H
16 #define LLVM_SUPPORT_LLVMBUILDER_H
18 #include "llvm/BasicBlock.h"
19 #include "llvm/Instructions.h"
20 #include "llvm/Constants.h"
24 /// LLVMBuilder - This provides a uniform API for creating instructions and
25 /// inserting them into a basic block: either at the end of a BasicBlock, or
26 /// at a specific iterator location in a block.
28 /// Note that the builder does not expose the full generality of LLVM
29 /// instructions. For example, it cannot be used to create instructions with
30 /// arbitrary names (specifically, names with nul characters in them) - It only
31 /// supports nul-terminated C strings. For fully generic names, use
32 /// I->setName(). For access to extra instruction properties, use the mutators
33 /// (e.g. setVolatile) on the instructions after they have been created.
36 BasicBlock::iterator InsertPt;
38 LLVMBuilder() { ClearInsertionPoint(); }
39 explicit LLVMBuilder(BasicBlock *TheBB) { SetInsertPoint(TheBB); }
40 LLVMBuilder(BasicBlock *TheBB, BasicBlock::iterator IP) {
41 SetInsertPoint(TheBB, IP);
44 //===--------------------------------------------------------------------===//
45 // Builder configuration methods
46 //===--------------------------------------------------------------------===//
48 /// ClearInsertionPoint - Clear the insertion point: created instructions will
49 /// not be inserted into a block.
50 void ClearInsertionPoint() {
54 BasicBlock *GetInsertBlock() const { return BB; }
56 /// SetInsertPoint - This specifies that created instructions should be
57 /// appended to the end of the specified block.
58 void SetInsertPoint(BasicBlock *TheBB) {
63 /// SetInsertPoint - This specifies that created instructions should be
64 /// inserted at the specified point.
65 void SetInsertPoint(BasicBlock *TheBB, BasicBlock::iterator IP) {
70 /// Insert - Insert and return the specified instruction.
71 template<typename InstTy>
72 InstTy *Insert(InstTy *I) const {
77 /// InsertHelper - Insert the specified instruction at the specified insertion
78 /// point. This is split out of Insert so that it isn't duplicated for every
79 /// template instantiation.
80 void InsertHelper(Instruction *I) const {
81 if (BB) BB->getInstList().insert(InsertPt, I);
84 //===--------------------------------------------------------------------===//
85 // Instruction creation methods: Terminators
86 //===--------------------------------------------------------------------===//
88 /// CreateRetVoid - Create a 'ret void' instruction.
89 ReturnInst *CreateRetVoid() {
90 return Insert(new ReturnInst());
94 /// CreateRet - Create a 'ret <val>' instruction.
96 ReturnInst *CreateRet(Value *V) {
97 return Insert(new ReturnInst(V));
100 /// CreateBr - Create an unconditional 'br label X' instruction.
101 BranchInst *CreateBr(BasicBlock *Dest) {
102 return Insert(new BranchInst(Dest));
105 /// CreateCondBr - Create a conditional 'br Cond, TrueDest, FalseDest'
107 BranchInst *CreateCondBr(Value *Cond, BasicBlock *True, BasicBlock *False) {
108 return Insert(new BranchInst(True, False, Cond));
111 /// CreateSwitch - Create a switch instruction with the specified value,
112 /// default dest, and with a hint for the number of cases that will be added
113 /// (for efficient allocation).
114 SwitchInst *CreateSwitch(Value *V, BasicBlock *Dest, unsigned NumCases = 10) {
115 return Insert(new SwitchInst(V, Dest, NumCases));
118 /// CreateInvoke - Create an invoke instruction.
119 template<typename InputIterator>
120 InvokeInst *CreateInvoke(Value *Callee, BasicBlock *NormalDest,
121 BasicBlock *UnwindDest, InputIterator ArgBegin,
122 InputIterator ArgEnd, const char *Name = "") {
123 return(Insert(new InvokeInst(Callee, NormalDest, UnwindDest,
124 ArgBegin, ArgEnd, Name)));
127 UnwindInst *CreateUnwind() {
128 return Insert(new UnwindInst());
131 UnreachableInst *CreateUnreachable() {
132 return Insert(new UnreachableInst());
135 //===--------------------------------------------------------------------===//
136 // Instruction creation methods: Binary Operators
137 //===--------------------------------------------------------------------===//
139 BinaryOperator *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") {
140 return Insert(BinaryOperator::createAdd(LHS, RHS, Name));
142 BinaryOperator *CreateSub(Value *LHS, Value *RHS, const char *Name = "") {
143 return Insert(BinaryOperator::createSub(LHS, RHS, Name));
145 BinaryOperator *CreateMul(Value *LHS, Value *RHS, const char *Name = "") {
146 return Insert(BinaryOperator::createMul(LHS, RHS, Name));
148 BinaryOperator *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") {
149 return Insert(BinaryOperator::createUDiv(LHS, RHS, Name));
151 BinaryOperator *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") {
152 return Insert(BinaryOperator::createSDiv(LHS, RHS, Name));
154 BinaryOperator *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") {
155 return Insert(BinaryOperator::createFDiv(LHS, RHS, Name));
157 BinaryOperator *CreateURem(Value *LHS, Value *RHS, const char *Name = "") {
158 return Insert(BinaryOperator::createURem(LHS, RHS, Name));
160 BinaryOperator *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") {
161 return Insert(BinaryOperator::createSRem(LHS, RHS, Name));
163 BinaryOperator *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") {
164 return Insert(BinaryOperator::createFRem(LHS, RHS, Name));
166 BinaryOperator *CreateShl(Value *LHS, Value *RHS, const char *Name = "") {
167 return Insert(BinaryOperator::createShl(LHS, RHS, Name));
169 BinaryOperator *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") {
170 return Insert(BinaryOperator::createLShr(LHS, RHS, Name));
172 BinaryOperator *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") {
173 return Insert(BinaryOperator::createAShr(LHS, RHS, Name));
175 BinaryOperator *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") {
176 return Insert(BinaryOperator::createAnd(LHS, RHS, Name));
178 BinaryOperator *CreateOr(Value *LHS, Value *RHS, const char *Name = "") {
179 return Insert(BinaryOperator::createOr(LHS, RHS, Name));
181 BinaryOperator *CreateXor(Value *LHS, Value *RHS, const char *Name = "") {
182 return Insert(BinaryOperator::createXor(LHS, RHS, Name));
185 BinaryOperator *CreateBinOp(Instruction::BinaryOps Opc,
186 Value *LHS, Value *RHS, const char *Name = "") {
187 return Insert(BinaryOperator::create(Opc, LHS, RHS, Name));
190 BinaryOperator *CreateNeg(Value *V, const char *Name = "") {
191 return Insert(BinaryOperator::createNeg(V, Name));
193 BinaryOperator *CreateNot(Value *V, const char *Name = "") {
194 return Insert(BinaryOperator::createNot(V, Name));
197 //===--------------------------------------------------------------------===//
198 // Instruction creation methods: Memory Instructions
199 //===--------------------------------------------------------------------===//
201 MallocInst *CreateMalloc(const Type *Ty, Value *ArraySize = 0,
202 const char *Name = "") {
203 return Insert(new MallocInst(Ty, ArraySize, Name));
205 AllocaInst *CreateAlloca(const Type *Ty, Value *ArraySize = 0,
206 const char *Name = "") {
207 return Insert(new AllocaInst(Ty, ArraySize, Name));
209 FreeInst *CreateFree(Value *Ptr) {
210 return Insert(new FreeInst(Ptr));
212 LoadInst *CreateLoad(Value *Ptr, const char *Name = 0) {
213 return Insert(new LoadInst(Ptr, Name));
215 LoadInst *CreateLoad(Value *Ptr, bool isVolatile, const char *Name = 0) {
216 return Insert(new LoadInst(Ptr, Name, isVolatile));
218 StoreInst *CreateStore(Value *Val, Value *Ptr, bool isVolatile = false) {
219 return Insert(new StoreInst(Val, Ptr, isVolatile));
221 template<typename InputIterator>
222 GetElementPtrInst *CreateGEP(Value *Ptr, InputIterator IdxBegin,
223 InputIterator IdxEnd, const char *Name = "") {
224 return(Insert(new GetElementPtrInst(Ptr, IdxBegin, IdxEnd, Name)));
226 GetElementPtrInst *CreateGEP(Value *Ptr, Value *Idx, const char *Name = "") {
227 return Insert(new GetElementPtrInst(Ptr, Idx, Name));
230 //===--------------------------------------------------------------------===//
231 // Instruction creation methods: Cast/Conversion Operators
232 //===--------------------------------------------------------------------===//
234 TruncInst *CreateTrunc(Value *V, const Type *DestTy, const char *Name = "") {
235 return Insert(new TruncInst(V, DestTy, Name));
237 ZExtInst *CreateZExt(Value *V, const Type *DestTy, const char *Name = "") {
238 return Insert(new ZExtInst(V, DestTy, Name));
240 SExtInst *CreateSExt(Value *V, const Type *DestTy, const char *Name = "") {
241 return Insert(new SExtInst(V, DestTy, Name));
243 FPToUIInst *CreateFPToUI(Value *V, const Type *DestTy, const char *Name = ""){
244 return Insert(new FPToUIInst(V, DestTy, Name));
246 FPToSIInst *CreateFPToSI(Value *V, const Type *DestTy, const char *Name = ""){
247 return Insert(new FPToSIInst(V, DestTy, Name));
249 UIToFPInst *CreateUIToFP(Value *V, const Type *DestTy, const char *Name = ""){
250 return Insert(new UIToFPInst(V, DestTy, Name));
252 SIToFPInst *CreateSIToFP(Value *V, const Type *DestTy, const char *Name = ""){
253 return Insert(new SIToFPInst(V, DestTy, Name));
255 FPTruncInst *CreateFPTrunc(Value *V, const Type *DestTy,
256 const char *Name = "") {
257 return Insert(new FPTruncInst(V, DestTy, Name));
259 FPExtInst *CreateFPExt(Value *V, const Type *DestTy, const char *Name = "") {
260 return Insert(new FPExtInst(V, DestTy, Name));
262 PtrToIntInst *CreatePtrToInt(Value *V, const Type *DestTy,
263 const char *Name = "") {
264 return Insert(new PtrToIntInst(V, DestTy, Name));
266 IntToPtrInst *CreateIntToPtr(Value *V, const Type *DestTy,
267 const char *Name = "") {
268 return Insert(new IntToPtrInst(V, DestTy, Name));
270 BitCastInst *CreateBitCast(Value *V, const Type *DestTy,
271 const char *Name = "") {
272 return Insert(new BitCastInst(V, DestTy, Name));
275 CastInst *CreateCast(Instruction::CastOps Op, Value *V, const Type *DestTy,
276 const char *Name = "") {
277 return Insert(CastInst::create(Op, V, DestTy, Name));
279 CastInst *CreateIntCast(Value *V, const Type *DestTy, bool isSigned,
280 const char *Name = "") {
281 return Insert(CastInst::createIntegerCast(V, DestTy, isSigned, Name));
286 //===--------------------------------------------------------------------===//
287 // Instruction creation methods: Compare Instructions
288 //===--------------------------------------------------------------------===//
290 ICmpInst *CreateICmpEQ(Value *LHS, Value *RHS, const char *Name = "") {
291 return Insert(new ICmpInst(ICmpInst::ICMP_EQ, LHS, RHS, Name));
293 ICmpInst *CreateICmpNE(Value *LHS, Value *RHS, const char *Name = "") {
294 return Insert(new ICmpInst(ICmpInst::ICMP_NE, LHS, RHS, Name));
296 ICmpInst *CreateICmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
297 return Insert(new ICmpInst(ICmpInst::ICMP_UGT, LHS, RHS, Name));
299 ICmpInst *CreateICmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
300 return Insert(new ICmpInst(ICmpInst::ICMP_UGE, LHS, RHS, Name));
302 ICmpInst *CreateICmpULT(Value *LHS, Value *RHS, const char *Name = "") {
303 return Insert(new ICmpInst(ICmpInst::ICMP_ULT, LHS, RHS, Name));
305 ICmpInst *CreateICmpULE(Value *LHS, Value *RHS, const char *Name = "") {
306 return Insert(new ICmpInst(ICmpInst::ICMP_ULE, LHS, RHS, Name));
308 ICmpInst *CreateICmpSGT(Value *LHS, Value *RHS, const char *Name = "") {
309 return Insert(new ICmpInst(ICmpInst::ICMP_SGT, LHS, RHS, Name));
311 ICmpInst *CreateICmpSGE(Value *LHS, Value *RHS, const char *Name = "") {
312 return Insert(new ICmpInst(ICmpInst::ICMP_SGE, LHS, RHS, Name));
314 ICmpInst *CreateICmpSLT(Value *LHS, Value *RHS, const char *Name = "") {
315 return Insert(new ICmpInst(ICmpInst::ICMP_SLT, LHS, RHS, Name));
317 ICmpInst *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") {
318 return Insert(new ICmpInst(ICmpInst::ICMP_SLE, LHS, RHS, Name));
321 FCmpInst *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") {
322 return Insert(new FCmpInst(FCmpInst::FCMP_OEQ, LHS, RHS, Name));
324 FCmpInst *CreateFCmpOGT(Value *LHS, Value *RHS, const char *Name = "") {
325 return Insert(new FCmpInst(FCmpInst::FCMP_OGT, LHS, RHS, Name));
327 FCmpInst *CreateFCmpOGE(Value *LHS, Value *RHS, const char *Name = "") {
328 return Insert(new FCmpInst(FCmpInst::FCMP_OGE, LHS, RHS, Name));
330 FCmpInst *CreateFCmpOLT(Value *LHS, Value *RHS, const char *Name = "") {
331 return Insert(new FCmpInst(FCmpInst::FCMP_OLT, LHS, RHS, Name));
333 FCmpInst *CreateFCmpOLE(Value *LHS, Value *RHS, const char *Name = "") {
334 return Insert(new FCmpInst(FCmpInst::FCMP_OLE, LHS, RHS, Name));
336 FCmpInst *CreateFCmpONE(Value *LHS, Value *RHS, const char *Name = "") {
337 return Insert(new FCmpInst(FCmpInst::FCMP_ONE, LHS, RHS, Name));
339 FCmpInst *CreateFCmpORD(Value *LHS, Value *RHS, const char *Name = "") {
340 return Insert(new FCmpInst(FCmpInst::FCMP_ORD, LHS, RHS, Name));
342 FCmpInst *CreateFCmpUNO(Value *LHS, Value *RHS, const char *Name = "") {
343 return Insert(new FCmpInst(FCmpInst::FCMP_UNO, LHS, RHS, Name));
345 FCmpInst *CreateFCmpUEQ(Value *LHS, Value *RHS, const char *Name = "") {
346 return Insert(new FCmpInst(FCmpInst::FCMP_UEQ, LHS, RHS, Name));
348 FCmpInst *CreateFCmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
349 return Insert(new FCmpInst(FCmpInst::FCMP_UGT, LHS, RHS, Name));
351 FCmpInst *CreateFCmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
352 return Insert(new FCmpInst(FCmpInst::FCMP_UGE, LHS, RHS, Name));
354 FCmpInst *CreateFCmpULT(Value *LHS, Value *RHS, const char *Name = "") {
355 return Insert(new FCmpInst(FCmpInst::FCMP_ULT, LHS, RHS, Name));
357 FCmpInst *CreateFCmpULE(Value *LHS, Value *RHS, const char *Name = "") {
358 return Insert(new FCmpInst(FCmpInst::FCMP_ULE, LHS, RHS, Name));
360 FCmpInst *CreateFCmpUNE(Value *LHS, Value *RHS, const char *Name = "") {
361 return Insert(new FCmpInst(FCmpInst::FCMP_UNE, LHS, RHS, Name));
365 ICmpInst *CreateICmp(ICmpInst::Predicate P, Value *LHS, Value *RHS,
366 const char *Name = "") {
367 return Insert(new ICmpInst(P, LHS, RHS, Name));
369 FCmpInst *CreateFCmp(FCmpInst::Predicate P, Value *LHS, Value *RHS,
370 const char *Name = "") {
371 return Insert(new FCmpInst(P, LHS, RHS, Name));
374 //===--------------------------------------------------------------------===//
375 // Instruction creation methods: Other Instructions
376 //===--------------------------------------------------------------------===//
378 PHINode *CreatePHI(const Type *Ty, const char *Name = "") {
379 return Insert(new PHINode(Ty, Name));
382 CallInst *CreateCall(Value *Callee, const char *Name = "") {
383 return Insert(new CallInst(Callee, Name));
385 CallInst *CreateCall(Value *Callee, Value *Arg, const char *Name = "") {
386 return Insert(new CallInst(Callee, Arg, Name));
389 template<typename InputIterator>
390 CallInst *CreateCall(Value *Callee, InputIterator ArgBegin,
391 InputIterator ArgEnd, const char *Name = "") {
392 return(Insert(new CallInst(Callee, ArgBegin, ArgEnd, Name)));
395 SelectInst *CreateSelect(Value *C, Value *True, Value *False,
396 const char *Name = "") {
397 return Insert(new SelectInst(C, True, False, Name));
400 VAArgInst *CreateVAArg(Value *List, const Type *Ty, const char *Name = "") {
401 return Insert(new VAArgInst(List, Ty, Name));
404 ExtractElementInst *CreateExtractElement(Value *Vec, Value *Idx,
405 const char *Name = "") {
406 return Insert(new ExtractElementInst(Vec, Idx, Name));
409 InsertElementInst *CreateInsertElement(Value *Vec, Value *NewElt, Value *Idx,
410 const char *Name = "") {
411 return Insert(new InsertElementInst(Vec, NewElt, Idx, Name));
414 ShuffleVectorInst *CreateShuffleVector(Value *V1, Value *V2, Value *Mask,
415 const char *Name = "") {
416 return Insert(new ShuffleVectorInst(V1, V2, Mask, Name));
420 /// LLVMFoldingBuilder - A version of LLVMBuilder that constant folds operands
422 class LLVMFoldingBuilder : public LLVMBuilder {
425 LLVMFoldingBuilder() {}
426 explicit LLVMFoldingBuilder(BasicBlock *TheBB)
427 : LLVMBuilder(TheBB) {}
428 LLVMFoldingBuilder(BasicBlock *TheBB, BasicBlock::iterator IP)
429 : LLVMBuilder(TheBB, IP) {}
431 //===--------------------------------------------------------------------===//
432 // Instruction creation methods: Binary Operators
433 //===--------------------------------------------------------------------===//
435 Value *CreateAdd(Value *LHS, Value *RHS, const char *Name = "") {
436 if (Constant *LC = dyn_cast<Constant>(LHS))
437 if (Constant *RC = dyn_cast<Constant>(RHS))
438 return ConstantExpr::getAdd(LC, RC);
439 return LLVMBuilder::CreateAdd(LHS, RHS, Name);
442 Value *CreateSub(Value *LHS, Value *RHS, const char *Name = "") {
443 if (Constant *LC = dyn_cast<Constant>(LHS))
444 if (Constant *RC = dyn_cast<Constant>(RHS))
445 return ConstantExpr::getSub(LC, RC);
446 return LLVMBuilder::CreateSub(LHS, RHS, Name);
449 Value *CreateMul(Value *LHS, Value *RHS, const char *Name = "") {
450 if (Constant *LC = dyn_cast<Constant>(LHS))
451 if (Constant *RC = dyn_cast<Constant>(RHS))
452 return ConstantExpr::getMul(LC, RC);
453 return LLVMBuilder::CreateMul(LHS, RHS, Name);
456 Value *CreateUDiv(Value *LHS, Value *RHS, const char *Name = "") {
457 if (Constant *LC = dyn_cast<Constant>(LHS))
458 if (Constant *RC = dyn_cast<Constant>(RHS))
459 return ConstantExpr::getUDiv(LC, RC);
460 return LLVMBuilder::CreateUDiv(LHS, RHS, Name);
463 Value *CreateSDiv(Value *LHS, Value *RHS, const char *Name = "") {
464 if (Constant *LC = dyn_cast<Constant>(LHS))
465 if (Constant *RC = dyn_cast<Constant>(RHS))
466 return ConstantExpr::getSDiv(LC, RC);
467 return LLVMBuilder::CreateSDiv(LHS, RHS, Name);
470 Value *CreateFDiv(Value *LHS, Value *RHS, const char *Name = "") {
471 if (Constant *LC = dyn_cast<Constant>(LHS))
472 if (Constant *RC = dyn_cast<Constant>(RHS))
473 return ConstantExpr::getFDiv(LC, RC);
474 return LLVMBuilder::CreateFDiv(LHS, RHS, Name);
477 Value *CreateURem(Value *LHS, Value *RHS, const char *Name = "") {
478 if (Constant *LC = dyn_cast<Constant>(LHS))
479 if (Constant *RC = dyn_cast<Constant>(RHS))
480 return ConstantExpr::getURem(LC, RC);
481 return LLVMBuilder::CreateURem(LHS, RHS, Name);
484 Value *CreateSRem(Value *LHS, Value *RHS, const char *Name = "") {
485 if (Constant *LC = dyn_cast<Constant>(LHS))
486 if (Constant *RC = dyn_cast<Constant>(RHS))
487 return ConstantExpr::getSRem(LC, RC);
488 return LLVMBuilder::CreateSRem(LHS, RHS, Name);
491 Value *CreateFRem(Value *LHS, Value *RHS, const char *Name = "") {
492 if (Constant *LC = dyn_cast<Constant>(LHS))
493 if (Constant *RC = dyn_cast<Constant>(RHS))
494 return ConstantExpr::getFRem(LC, RC);
495 return LLVMBuilder::CreateFRem(LHS, RHS, Name);
498 Value *CreateAnd(Value *LHS, Value *RHS, const char *Name = "") {
499 if (Constant *LC = dyn_cast<Constant>(LHS))
500 if (Constant *RC = dyn_cast<Constant>(RHS))
501 return ConstantExpr::getAnd(LC, RC);
502 return LLVMBuilder::CreateAnd(LHS, RHS, Name);
505 Value *CreateOr(Value *LHS, Value *RHS, const char *Name = "") {
506 if (Constant *LC = dyn_cast<Constant>(LHS))
507 if (Constant *RC = dyn_cast<Constant>(RHS))
508 return ConstantExpr::getOr(LC, RC);
509 return LLVMBuilder::CreateOr(LHS, RHS, Name);
512 Value *CreateXor(Value *LHS, Value *RHS, const char *Name = "") {
513 if (Constant *LC = dyn_cast<Constant>(LHS))
514 if (Constant *RC = dyn_cast<Constant>(RHS))
515 return ConstantExpr::getXor(LC, RC);
516 return LLVMBuilder::CreateXor(LHS, RHS, Name);
519 Value *CreateShl(Value *LHS, Value *RHS, const char *Name = "") {
520 if (Constant *LC = dyn_cast<Constant>(LHS))
521 if (Constant *RC = dyn_cast<Constant>(RHS))
522 return ConstantExpr::getShl(LC, RC);
523 return LLVMBuilder::CreateShl(LHS, RHS, Name);
526 Value *CreateLShr(Value *LHS, Value *RHS, const char *Name = "") {
527 if (Constant *LC = dyn_cast<Constant>(LHS))
528 if (Constant *RC = dyn_cast<Constant>(RHS))
529 return ConstantExpr::getLShr(LC, RC);
530 return LLVMBuilder::CreateLShr(LHS, RHS, Name);
533 Value *CreateAShr(Value *LHS, Value *RHS, const char *Name = "") {
534 if (Constant *LC = dyn_cast<Constant>(LHS))
535 if (Constant *RC = dyn_cast<Constant>(RHS))
536 return ConstantExpr::getAShr(LC, RC);
537 return LLVMBuilder::CreateAShr(LHS, RHS, Name);
540 //===--------------------------------------------------------------------===//
541 // Instruction creation methods: Compare Instructions
542 //===--------------------------------------------------------------------===//
544 Value *CreateICmpEQ(Value *LHS, Value *RHS, const char *Name = "") {
545 return CreateICmp(ICmpInst::ICMP_EQ, LHS, RHS, Name);
547 Value *CreateICmpNE(Value *LHS, Value *RHS, const char *Name = "") {
548 return CreateICmp(ICmpInst::ICMP_NE, LHS, RHS, Name);
550 Value *CreateICmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
551 return CreateICmp(ICmpInst::ICMP_UGT, LHS, RHS, Name);
553 Value *CreateICmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
554 return CreateICmp(ICmpInst::ICMP_UGE, LHS, RHS, Name);
556 Value *CreateICmpULT(Value *LHS, Value *RHS, const char *Name = "") {
557 return CreateICmp(ICmpInst::ICMP_ULT, LHS, RHS, Name);
559 Value *CreateICmpULE(Value *LHS, Value *RHS, const char *Name = "") {
560 return CreateICmp(ICmpInst::ICMP_ULE, LHS, RHS, Name);
562 Value *CreateICmpSGT(Value *LHS, Value *RHS, const char *Name = "") {
563 return CreateICmp(ICmpInst::ICMP_SGT, LHS, RHS, Name);
565 Value *CreateICmpSGE(Value *LHS, Value *RHS, const char *Name = "") {
566 return CreateICmp(ICmpInst::ICMP_SGE, LHS, RHS, Name);
568 Value *CreateICmpSLT(Value *LHS, Value *RHS, const char *Name = "") {
569 return CreateICmp(ICmpInst::ICMP_SLT, LHS, RHS, Name);
571 Value *CreateICmpSLE(Value *LHS, Value *RHS, const char *Name = "") {
572 return CreateICmp(ICmpInst::ICMP_SLE, LHS, RHS, Name);
575 Value *CreateFCmpOEQ(Value *LHS, Value *RHS, const char *Name = "") {
576 return CreateFCmp(FCmpInst::FCMP_OEQ, LHS, RHS, Name);
578 Value *CreateFCmpOGT(Value *LHS, Value *RHS, const char *Name = "") {
579 return CreateFCmp(FCmpInst::FCMP_OGT, LHS, RHS, Name);
581 Value *CreateFCmpOGE(Value *LHS, Value *RHS, const char *Name = "") {
582 return CreateFCmp(FCmpInst::FCMP_OGE, LHS, RHS, Name);
584 Value *CreateFCmpOLT(Value *LHS, Value *RHS, const char *Name = "") {
585 return CreateFCmp(FCmpInst::FCMP_OLT, LHS, RHS, Name);
587 Value *CreateFCmpOLE(Value *LHS, Value *RHS, const char *Name = "") {
588 return CreateFCmp(FCmpInst::FCMP_OLE, LHS, RHS, Name);
590 Value *CreateFCmpONE(Value *LHS, Value *RHS, const char *Name = "") {
591 return CreateFCmp(FCmpInst::FCMP_ONE, LHS, RHS, Name);
593 Value *CreateFCmpORD(Value *LHS, Value *RHS, const char *Name = "") {
594 return CreateFCmp(FCmpInst::FCMP_ORD, LHS, RHS, Name);
596 Value *CreateFCmpUNO(Value *LHS, Value *RHS, const char *Name = "") {
597 return CreateFCmp(FCmpInst::FCMP_UNO, LHS, RHS, Name);
599 Value *CreateFCmpUEQ(Value *LHS, Value *RHS, const char *Name = "") {
600 return CreateFCmp(FCmpInst::FCMP_UEQ, LHS, RHS, Name);
602 Value *CreateFCmpUGT(Value *LHS, Value *RHS, const char *Name = "") {
603 return CreateFCmp(FCmpInst::FCMP_UGT, LHS, RHS, Name);
605 Value *CreateFCmpUGE(Value *LHS, Value *RHS, const char *Name = "") {
606 return CreateFCmp(FCmpInst::FCMP_UGE, LHS, RHS, Name);
608 Value *CreateFCmpULT(Value *LHS, Value *RHS, const char *Name = "") {
609 return CreateFCmp(FCmpInst::FCMP_ULT, LHS, RHS, Name);
611 Value *CreateFCmpULE(Value *LHS, Value *RHS, const char *Name = "") {
612 return CreateFCmp(FCmpInst::FCMP_ULE, LHS, RHS, Name);
614 Value *CreateFCmpUNE(Value *LHS, Value *RHS, const char *Name = "") {
615 return CreateFCmp(FCmpInst::FCMP_UNE, LHS, RHS, Name);
618 Value *CreateICmp(ICmpInst::Predicate P, Value *LHS, Value *RHS,
619 const char *Name = "") {
620 if (Constant *LC = dyn_cast<Constant>(LHS))
621 if (Constant *RC = dyn_cast<Constant>(RHS))
622 return ConstantExpr::getCompare(P, LC, RC);
623 return LLVMBuilder::CreateICmp(P, LHS, RHS, Name);
626 Value *CreateFCmp(FCmpInst::Predicate P, Value *LHS, Value *RHS,
627 const char *Name = "") {
628 if (Constant *LC = dyn_cast<Constant>(LHS))
629 if (Constant *RC = dyn_cast<Constant>(RHS))
630 return ConstantExpr::getCompare(P, LC, RC);
631 return LLVMBuilder::CreateFCmp(P, LHS, RHS, Name);