| /src/external/apache2/llvm/dist/llvm/include/llvm/IR/ |
| ReplaceConstant.h | 24 Instruction *createReplacementInstr(ConstantExpr *CE, Instruction *Instr);
|
| ConstantFolder.h | 12 // use ConstantExpr and the routines in llvm/Analysis/ConstantFolding.h.
40 return ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW);
44 return ConstantExpr::getFAdd(LHS, RHS);
49 return ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW);
53 return ConstantExpr::getFSub(LHS, RHS);
58 return ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW);
62 return ConstantExpr::getFMul(LHS, RHS);
67 return ConstantExpr::getUDiv(LHS, RHS, isExact);
72 return ConstantExpr::getSDiv(LHS, RHS, isExact);
76 return ConstantExpr::getFDiv(LHS, RHS)
[all...] |
| Operator.h | 39 /// Return the opcode for this Instruction or ConstantExpr.
43 return cast<ConstantExpr>(this)->getOpcode();
46 /// If V is an Instruction or ConstantExpr, return its opcode.
51 if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V))
57 static bool classof(const ConstantExpr *) { return true; }
59 return isa<Instruction>(V) || isa<ConstantExpr>(V);
76 friend class ConstantExpr;
106 static bool classof(const ConstantExpr *CE) {
114 (isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V)))
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Analysis/ |
| TargetFolder.h | 13 // creation and folding, use ConstantExpr and the routines in
51 return Fold(ConstantExpr::getAdd(LHS, RHS, HasNUW, HasNSW));
54 return Fold(ConstantExpr::getFAdd(LHS, RHS));
58 return Fold(ConstantExpr::getSub(LHS, RHS, HasNUW, HasNSW));
61 return Fold(ConstantExpr::getFSub(LHS, RHS));
65 return Fold(ConstantExpr::getMul(LHS, RHS, HasNUW, HasNSW));
68 return Fold(ConstantExpr::getFMul(LHS, RHS));
72 return Fold(ConstantExpr::getUDiv(LHS, RHS, isExact));
76 return Fold(ConstantExpr::getSDiv(LHS, RHS, isExact));
79 return Fold(ConstantExpr::getFDiv(LHS, RHS))
[all...] |
| ConstantFolding.h | 12 // Also, to supplement the basic VMCore ConstantExpr simplifications,
27 class ConstantExpr;
137 /// getelementptr constantexpr, return the constant value being addressed by the
139 Constant *ConstantFoldLoadThroughGEPConstantExpr(Constant *C, ConstantExpr *CE,
|
| /src/external/apache2/llvm/dist/llvm/lib/IR/ |
| ConstantsContext.h | 46 class UnaryConstantExpr final : public ConstantExpr {
49 : ConstantExpr(Ty, Opcode, &Op<0>(), 1) {
60 static bool classof(const ConstantExpr *CE) {
65 return isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V));
71 class BinaryConstantExpr final : public ConstantExpr {
75 : ConstantExpr(C1->getType(), Opcode, &Op<0>(), 2) {
89 static bool classof(const ConstantExpr *CE) {
93 return isa<ConstantExpr>(V) && classof(cast<ConstantExpr>(V))
[all...] |
| ConstantFold.cpp | 11 // ConstantExpr::get* methods to automatically fold constants when possible.
66 ConstantExpr::getBitCast(Splat, DstEltTy));
73 ConstantExpr::getExtractElement(CV, ConstantInt::get(Ty, i));
74 C = ConstantExpr::getBitCast(C, DstEltTy);
88 ConstantExpr *Op, ///< the first cast constant expression
134 return ConstantExpr::getInBoundsGetElementPtr(PTy->getElementType(),
158 return ConstantExpr::getBitCast(ConstantVector::get(V), DestPTy);
235 ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
253 return ConstantExpr::getOr(LHS, RHS)
[all...] |
| Constants.cpp | 301 Constant *C0 = ConstantExpr::getBitCast(const_cast<Constant *>(this), IntTy);
302 Constant *C1 = ConstantExpr::getBitCast(cast<Constant>(Y), IntTy);
303 Constant *CmpEq = ConstantExpr::getICmp(ICmpInst::ICMP_EQ, C0, C1);
340 if (isa<ConstantExpr>(getAggregateElement(i)))
396 C = ConstantExpr::getIntToPtr(C, PTy);
574 SmallPtrSetImpl<const ConstantExpr *> &NonTrappingOps) {
577 const ConstantExpr *CE = dyn_cast<ConstantExpr>(C);
581 // ConstantExpr traps if any operands can trap.
583 if (ConstantExpr *Op = dyn_cast<ConstantExpr>(CE->getOperand(i)))
[all...] |
| AbstractCallSite.cpp | 66 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(U->getUser()))
|
| ReplaceConstant.cpp | 22 Instruction *createReplacementInstr(ConstantExpr *CE, Instruction *Instr) {
|
| /src/external/apache2/llvm/dist/llvm/include/llvm/Transforms/Scalar/ |
| ConstantHoisting.h | 55 class ConstantExpr;
82 // If the candidate is a ConstantExpr (currely only constant GEP expressions
86 ConstantExpr *ConstExpr;
89 ConstantCandidate(ConstantInt *ConstInt, ConstantExpr *ConstExpr=nullptr) :
114 // If the candidate is a ConstantExpr (currely only constant GEP expressions
118 ConstantExpr *BaseExpr;
146 using ConstPtrUnionType = PointerUnion<ConstantInt *, ConstantExpr *>;
180 ConstantExpr *ConstExpr);
|
| /src/external/apache2/llvm/dist/llvm/lib/Bitcode/Reader/ |
| ValueList.cpp | 33 class ConstantPlaceHolder : public ConstantExpr {
36 : ConstantExpr(Ty, Instruction::UserOp1, &Op<0>(), 1) {
47 return isa<ConstantExpr>(V) &&
48 cast<ConstantExpr>(V)->getOpcode() == Instruction::UserOp1;
57 // FIXME: can we inherit this from ConstantExpr?
209 assert(isa<ConstantExpr>(UserC) && "Must be a ConstantExpr.");
210 NewC = cast<ConstantExpr>(UserC)->getWithOperands(NewOps);
|
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/IPO/ |
| Annotation2Metadata.cpp | 50 auto *StrGEP = dyn_cast<ConstantExpr>(OpC->getOperand(1));
60 auto *Bitcast = dyn_cast<ConstantExpr>(OpC->getOperand(0));
|
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Utils/ |
| Evaluator.cpp | 83 ConstantExpr *CE = cast<ConstantExpr>(C);
140 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
141 // Handle a constantexpr gep.
165 // A constantexpr bitcast from a pointer to another pointer is a no-op,
198 Ptr = ConstantExpr::getGetElementPtr(Ty, Ptr, IdxList);
226 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(P)) {
228 // Handle a constantexpr getelementptr
[all...] |
| SanitizerStats.cpp | 52 ConstantExpr::getIntToPtr(
62 auto InitAddr = ConstantExpr::getGetElementPtr(
68 B.CreateCall(StatReport, ConstantExpr::getBitCast(InitAddr, Int8PtrTy));
90 ConstantExpr::getBitCast(NewModuleStatsGV, ModuleStatsGV->getType()));
103 B.CreateCall(StatInit, ConstantExpr::getBitCast(NewModuleStatsGV, Int8PtrTy));
|
| CanonicalizeAliases.cpp | 52 auto *CE = dyn_cast<ConstantExpr>(C);
|
| RelLookupTableConverter.cpp | 111 Constant *Base = llvm::ConstantExpr::getPtrToInt(RelLookupTable, IntPtrTy);
112 Constant *Target = llvm::ConstantExpr::getPtrToInt(Element, IntPtrTy);
113 Constant *Sub = llvm::ConstantExpr::getSub(Target, Base);
115 llvm::ConstantExpr::getTrunc(Sub, Type::getInt32Ty(M.getContext()));
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/AMDGPU/ |
| AMDGPUOpenCLEnqueuedBlockLowering.cpp | 127 if (!isa<ConstantExpr>(UU))
130 auto *BitCast = cast<ConstantExpr>(UU);
131 auto *NewPtr = ConstantExpr::getPointerCast(GV, BitCast->getType());
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/NVPTX/ |
| NVVMReflect.cpp | 136 assert(isa<ConstantExpr>(Str) &&
138 const ConstantExpr *GEP = cast<ConstantExpr>(Str);
|
| NVPTXGenericToNVVM.cpp | 52 Value *remapConstantExpr(Module *M, Function *F, ConstantExpr *C,
142 Constant *BitCastNewGV = ConstantExpr::getPointerCast(NewGV, GV->getType());
184 } else if (isa<ConstantExpr>(C)) {
188 NewValue = remapConstantExpr(M, F, cast<ConstantExpr>(C), Builder);
234 Value *GenericToNVVM::remapConstantExpr(Module *M, Function *F, ConstantExpr *C,
309 llvm_unreachable("GenericToNVVM encountered an unsupported ConstantExpr");
|
| /src/external/apache2/llvm/dist/llvm/lib/Target/XCore/ |
| XCoreLowerThreadLocal.cpp | 79 static bool replaceConstantExprOp(ConstantExpr *CE, Pass *P) {
100 ConstantExpr *CExpr = dyn_cast<ConstantExpr>(WU);
118 ConstantExpr *CE = dyn_cast<ConstantExpr>(WU);
|
| /src/external/apache2/llvm/dist/llvm/lib/Transforms/Scalar/ |
| InferAddressSpaces.cpp | 399 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) {
414 if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Op->getOperand(I))) {
515 return ConstantExpr::getAddrSpaceCast(C, NewPtrTy);
634 ConstantExpr *CE, unsigned NewAddrSpace,
646 return ConstantExpr::getBitCast(CE->getOperand(0), TargetType);
651 return ConstantExpr::getBitCast(cast<Constant>(NewOperand), TargetType);
652 return ConstantExpr::getAddrSpaceCast(CE, TargetType);
661 return ConstantExpr::getSelect
[all...] |
| /src/external/apache2/llvm/dist/llvm/include/llvm/Analysis/Utils/ |
| Local.h | 23 /// Given a getelementptr instruction/constantexpr, emit the code necessary to
70 ConstantExpr::getIntegerCast(OpC, IntIdxTy, true /*SExt*/);
72 ConstantExpr::getMul(OC, Scale, false /*NUW*/, isInBounds /*NSW*/);
|
| /src/external/apache2/llvm/dist/llvm/lib/Analysis/ |
| ConstantFolding.cpp | 11 // Also, to supplement the basic IR ConstantExpr simplifications,
92 return ConstantExpr::getBitCast(C, DestTy);
103 /// ConstantExpr if unfoldable.
106 "Invalid constantexpr bitcast!");
128 C = ConstantExpr::getBitCast(C, SrcIVTy);
147 return ConstantExpr::getBitCast(C, DestTy);
158 return ConstantExpr::getBitCast(C, DestTy);
164 return ConstantExpr::getBitCast(C, DestTy);
188 return ConstantExpr::getBitCast(C, DestTy);
198 C = ConstantExpr::getBitCast(C, SrcIVTy)
[all...] |
| /src/external/apache2/llvm/dist/clang/lib/CodeGen/ |
| ConstantInitBuilder.cpp | 98 llvm::ConstantExpr::getInBoundsGetElementPtr(
141 base = llvm::ConstantExpr::getPtrToInt(base, Builder.CGM.IntPtrTy);
142 target = llvm::ConstantExpr::getPtrToInt(target, Builder.CGM.IntPtrTy);
143 llvm::Constant *offset = llvm::ConstantExpr::getSub(target, base);
147 offset = llvm::ConstantExpr::getTrunc(offset, offsetType);
|
