Lines Matching refs:Constant
31 #include "llvm/IR/Constant.h"
64 // Constant Folding internal helper functions
67 static Constant *foldConstVectorToAPInt(APInt &Result, Type *DestTy,
68 Constant *C, Type *SrcEltTy,
75 Constant *Element;
97 /// Constant fold bitcast, symbolically evaluating it with DataLayout.
100 Constant *FoldBitCast(Constant *C, Type *DestTy, const DataLayout &DL) {
106 return Constant::getNullValue(DestTy);
109 return Constant::getAllOnesValue(DestTy);
128 if (Constant *CE = foldConstVectorToAPInt(Result, DestTy, C,
148 Constant *Ops = C; // don't take the address of C!
207 SmallVector<Constant*, 32> Result;
210 Constant *Zero = Constant::getNullValue(DstEltTy);
216 Constant *Elt = Zero;
219 Constant *Src = C->getAggregateElement(SrcElt++);
221 Src = Constant::getNullValue(
269 Constant *Elt = ConstantExpr::getLShr(Src,
277 Constant *CE = ConstantExpr::getTrunc(Elt, DstIntTy);
294 bool llvm::IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV,
332 Constant *llvm::ConstantFoldLoadThroughBitcast(Constant *C, Type *DestTy,
344 return Constant::getNullValue(DestTy);
351 return Constant::getAllOnesValue(DestTy);
384 Constant *ElemC;
403 bool ReadDataFromGlobal(Constant *C, uint64_t ByteOffset, unsigned char *CurPtr,
528 Constant *FoldReinterpretLoadFromConstPtr(Constant *C, Type *LoadTy,
559 if (Constant *Res = FoldReinterpretLoadFromConstPtr(C, MapTy, DL)) {
562 return Constant::getNullValue(LoadTy);
568 return Constant::getNullValue(LoadTy);
637 Constant *ConstantFoldLoadThroughBitcastExpr(ConstantExpr *CE, Type *DestTy,
645 Constant *C = ConstantFoldLoadFromConstPtr(SrcPtr, SrcTy, DL);
654 Constant *llvm::ConstantFoldLoadFromConstPtr(Constant *C, Type *Ty,
673 if (Constant *V =
681 if (Constant *LoadedC = ConstantFoldLoadThroughBitcastExpr(CE, Ty, DL))
711 Constant *Res = ConstantInt::get(CE->getContext(), StrVal);
723 return Constant::getNullValue(Ty);
735 Constant *ConstantFoldLoadInst(const LoadInst *LI, const DataLayout &DL) {
738 if (auto *C = dyn_cast<Constant>(LI->getOperand(0)))
748 Constant *SymbolicallyEvaluateBinop(unsigned Opc, Constant *Op0, Constant *Op1,
796 Constant *CastGEPIndices(Type *SrcElemTy, ArrayRef<Constant *> Ops,
803 SmallVector<Constant*, 32> NewIdxs;
825 Constant *C = ConstantExpr::getGetElementPtr(
831 Constant *StripPtrCastKeepAS(Constant *Ptr, Type *&ElemTy) {
834 Ptr = cast<Constant>(Ptr->stripPointerCasts());
848 Constant *SymbolicallyEvaluateGEP(const GEPOperator *GEP,
849 ArrayRef<Constant *> Ops,
861 if (Constant *C = CastGEPIndices(SrcElemTy, Ops, ResTy,
865 Constant *Ptr = Ops[0];
884 Constant *Res = ConstantExpr::getPtrToInt(Ptr, CE->getType());
918 Ptr = cast<Constant>(GEP->getOperand(0));
937 Constant *C = ConstantInt::get(Ptr->getContext(), Offset + BasePtr);
946 SmallVector<Constant *, 32> NewIdxs;
1024 Constant *C = ConstantExpr::getGetElementPtr(SrcElemTy, Ptr, NewIdxs,
1042 Constant *ConstantFoldInstOperandsImpl(const Value *InstOrCE, unsigned Opcode,
1043 ArrayRef<Constant *> Ops,
1058 if (Constant *C = SymbolicallyEvaluateGEP(GEP, Ops, DL, TLI))
1098 // Constant Folding public APIs
1103 Constant *
1104 ConstantFoldConstantImpl(const Constant *C, const DataLayout &DL,
1106 SmallDenseMap<Constant *, Constant *> &FoldedOps) {
1108 return const_cast<Constant *>(C);
1110 SmallVector<Constant *, 8> Ops;
1112 Constant *OldC = cast<Constant>(&OldU);
1113 Constant *NewC = OldC;
1142 Constant *llvm::ConstantFoldInstruction(Instruction *I, const DataLayout &DL,
1146 Constant *CommonValue = nullptr;
1148 SmallDenseMap<Constant *, Constant *> FoldedOps;
1157 auto *C = dyn_cast<Constant>(Incoming);
1175 if (!all_of(I->operands(), [](Use &U) { return isa<Constant>(U); }))
1178 SmallDenseMap<Constant *, Constant *> FoldedOps;
1179 SmallVector<Constant *, 8> Ops;
1181 auto *Op = cast<Constant>(&OpU);
1196 cast<Constant>(IVI->getAggregateOperand()),
1197 cast<Constant>(IVI->getInsertedValueOperand()),
1203 cast<Constant>(EVI->getAggregateOperand()),
1210 Constant *llvm::ConstantFoldConstant(const Constant *C, const DataLayout &DL,
1212 SmallDenseMap<Constant *, Constant *> FoldedOps;
1216 Constant *llvm::ConstantFoldInstOperands(Instruction *I,
1217 ArrayRef<Constant *> Ops,
1223 Constant *llvm::ConstantFoldCompareInstOperands(unsigned Predicate,
1224 Constant *Ops0, Constant *Ops1,
1243 Constant *C = ConstantExpr::getIntegerCast(CE0->getOperand(0),
1245 Constant *Null = Constant::getNullValue(C->getType());
1254 Constant *C = CE0->getOperand(0);
1255 Constant *Null = Constant::getNullValue(C->getType());
1268 Constant *C0 = ConstantExpr::getIntegerCast(CE0->getOperand(0),
1270 Constant *C1 = ConstantExpr::getIntegerCast(CE1->getOperand(0),
1292 Constant *LHS = ConstantFoldCompareInstOperands(
1294 Constant *RHS = ConstantFoldCompareInstOperands(
1310 Constant *llvm::ConstantFoldUnaryOpOperand(unsigned Opcode, Constant *Op,
1317 Constant *llvm::ConstantFoldBinaryOpOperands(unsigned Opcode, Constant *LHS,
1318 Constant *RHS,
1322 if (Constant *C = SymbolicallyEvaluateBinop(Opcode, LHS, RHS, DL))
1328 Constant *llvm::ConstantFoldCastOperand(unsigned Opcode, Constant *C,
1339 Constant *Input = CE->getOperand(0);
1343 Constant *Mask =
1360 Constant *SrcPtr = CE->getOperand(0);
1389 Constant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C,
1404 Constant *
1405 llvm::ConstantFoldLoadThroughGEPIndices(Constant *C,
1406 ArrayRef<Constant *> Indices) {
1409 for (Constant *Index : Indices) {
1418 // Constant Folding for Calls
1625 Constant *GetConstantFoldFPValue(double V, Type *Ty) {
1657 Constant *ConstantFoldFP(double (*NativeFP)(double), double V, Type *Ty) {
1668 Constant *ConstantFoldBinaryFP(double (*NativeFP)(double, double), double V,
1680 Constant *ConstantFoldVectorReduce(Intrinsic::ID IID, Constant *Op) {
1733 /// returns the Constant value resulting from the conversion.
1734 Constant *ConstantFoldSSEConvertToInt(const APFloat &Val, bool roundTowardZero,
1769 static bool isManifestConstant(const Constant *c) {
1774 if (!isManifestConstant(cast<Constant>(subc)))
1794 static Constant *ConstantFoldScalarCall1(StringRef Name,
1797 ArrayRef<Constant *> Operands,
1803 // We know we have a "Constant" argument. But we want to only
1815 return Constant::getNullValue(Ty);
2205 auto *Op = cast<Constant>(Operands[0]);
2217 if (Constant *C = ConstantFoldVectorReduce(IntrinsicID, Op))
2246 static Constant *ConstantFoldScalarCall2(StringRef Name,
2249 ArrayRef<Constant *> Operands,
2395 Constant::getNullValue(Ty->getStructElementType(1))});
2403 return Constant::getNullValue(Ty);
2428 Constant *Ops[] = {
2439 return Constant::getAllOnesValue(Ty);
2449 return Constant::getNullValue(Ty);
2462 return Constant::getNullValue(Ty);
2479 auto *Op = cast<Constant>(Operands[0]);
2582 static Constant *ConstantFoldScalarCall3(StringRef Name,
2585 ArrayRef<Constant *> Operands,
2686 static Constant *ConstantFoldScalarCall(StringRef Name,
2689 ArrayRef<Constant *> Operands,
2704 static Constant *ConstantFoldVectorCall(StringRef Name,
2707 ArrayRef<Constant *> Operands,
2718 SmallVector<Constant *, 4> Result(FVTy->getNumElements());
2719 SmallVector<Constant *, 4> Lane(Operands.size());
2727 Constant *VecData = ConstantFoldLoadFromConstPtr(SrcPtr, FVTy, DL);
2729 SmallVector<Constant *, 32> NewElements;
2770 Constant *Agg = Operands[J]->getAggregateElement(I);
2778 Constant *Folded =
2790 Constant *llvm::ConstantFoldCall(const CallBase *Call, Function *F,
2791 ArrayRef<Constant *> Operands,