ConstantFolding.cpp revision de0e587e63f71afb2ac53c9880c262089fe798bb
1bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell//===-- ConstantFolding.cpp - Analyze constant folding possibilities ------===// 2bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell// 3bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell// The LLVM Compiler Infrastructure 4bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell// 8bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell//===----------------------------------------------------------------------===// 9bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell// 10bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell// This family of functions determines the possibility of performing constant 11bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell// folding. 12bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell// 13bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell//===----------------------------------------------------------------------===// 14bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 15bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Analysis/ConstantFolding.h" 16bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Constants.h" 17bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/DerivedTypes.h" 185520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner#include "llvm/Function.h" 199a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman#include "llvm/GlobalVariable.h" 20bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Instructions.h" 21bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Intrinsics.h" 22508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson#include "llvm/LLVMContext.h" 235520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner#include "llvm/ADT/SmallVector.h" 24c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner#include "llvm/ADT/StringMap.h" 2503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner#include "llvm/Target/TargetData.h" 26c25e7581b9b8088910da31702d4ca21c4734c6d7Torok Edwin#include "llvm/Support/ErrorHandling.h" 27bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Support/GetElementPtrTypeIterator.h" 28bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Support/MathExtras.h" 29bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include <cerrno> 3097af751deb9b26fd42fbcee082da9ccc4ded5b45Jeff Cohen#include <cmath> 31bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswellusing namespace llvm; 32bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 3303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner//===----------------------------------------------------------------------===// 3403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner// Constant Folding internal helper functions 3503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner//===----------------------------------------------------------------------===// 3603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 3703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// IsConstantOffsetFromGlobal - If this constant is actually a constant offset 3803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// from a global, return the global and the constant. Because of 3903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// constantexprs, this function is recursive. 4003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattnerstatic bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, 4103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner int64_t &Offset, const TargetData &TD) { 4203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Trivial case, constant is the global. 4303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if ((GV = dyn_cast<GlobalValue>(C))) { 4403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner Offset = 0; 4503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return true; 4603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 4703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 4803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Otherwise, if this isn't a constant expr, bail out. 4903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner ConstantExpr *CE = dyn_cast<ConstantExpr>(C); 5003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (!CE) return false; 5103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 5203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Look through ptr->int and ptr->ptr casts. 5303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (CE->getOpcode() == Instruction::PtrToInt || 5403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner CE->getOpcode() == Instruction::BitCast) 5503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return IsConstantOffsetFromGlobal(CE->getOperand(0), GV, Offset, TD); 5603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 5703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // i32* getelementptr ([5 x i32]* @a, i32 0, i32 5) 5803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (CE->getOpcode() == Instruction::GetElementPtr) { 5903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Cannot compute this if the element type of the pointer is missing size 6003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // info. 61f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (!cast<PointerType>(CE->getOperand(0)->getType()) 62f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner ->getElementType()->isSized()) 6303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return false; 6403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 6503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // If the base isn't a global+constant, we aren't either. 6603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (!IsConstantOffsetFromGlobal(CE->getOperand(0), GV, Offset, TD)) 6703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return false; 6803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 6903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Otherwise, add any offset that our operands provide. 7003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner gep_type_iterator GTI = gep_type_begin(CE); 71de2d74b213844b17eb5327fba27f21e699d3af66Gabor Greif for (User::const_op_iterator i = CE->op_begin() + 1, e = CE->op_end(); 72785c6af9797fcf551feef70f2ecb5cd075b6e3c4Gabor Greif i != e; ++i, ++GTI) { 73de2d74b213844b17eb5327fba27f21e699d3af66Gabor Greif ConstantInt *CI = dyn_cast<ConstantInt>(*i); 7403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (!CI) return false; // Index isn't a simple constant? 7503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (CI->getZExtValue() == 0) continue; // Not adding anything. 7603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 7703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (const StructType *ST = dyn_cast<StructType>(*GTI)) { 7803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // N = N + Offset 79b1919e2f08ecb37140af676fd2916f8d5ed7df3dChris Lattner Offset += TD.getStructLayout(ST)->getElementOffset(CI->getZExtValue()); 8003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } else { 81ca5183d445954a9b2a570d6bbba1bc2b00ad6442Jeff Cohen const SequentialType *SQT = cast<SequentialType>(*GTI); 82777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands Offset += TD.getTypeAllocSize(SQT->getElementType())*CI->getSExtValue(); 8303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 8403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 8503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return true; 8603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 8703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 8803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return false; 8903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner} 9003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 9103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 9203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// SymbolicallyEvaluateBinop - One of Op0/Op1 is a constant expression. 9367e3566d8f6875e9c92d224f493023408a66227eNick Lewycky/// Attempt to symbolically evaluate the result of a binary operator merging 9403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// these together. If target data info is available, it is provided as TD, 9503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// otherwise TD is null. 9603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattnerstatic Constant *SymbolicallyEvaluateBinop(unsigned Opc, Constant *Op0, 97508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Constant *Op1, const TargetData *TD, 98e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context){ 9903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // SROA 10003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 10103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Fold (and 0xffffffff00000000, (shl x, 32)) -> shl. 10203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Fold (lshr (or X, Y), 32) -> (lshr [X/Y], 32) if one doesn't contribute 10303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // bits. 10403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 10503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 10603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // If the constant expr is something like &A[123] - &A[4].f, fold this into a 10703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // constant. This happens frequently when iterating over a global array. 10803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (Opc == Instruction::Sub && TD) { 10903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner GlobalValue *GV1, *GV2; 11003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner int64_t Offs1, Offs2; 11103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 11203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (IsConstantOffsetFromGlobal(Op0, GV1, Offs1, *TD)) 11303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (IsConstantOffsetFromGlobal(Op1, GV2, Offs2, *TD) && 11403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner GV1 == GV2) { 11503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // (&GV+C1) - (&GV+C2) -> C1-C2, pointer arithmetic cannot overflow. 116eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return ConstantInt::get(Op0->getType(), Offs1-Offs2); 11703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 11803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 11903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 12003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return 0; 12103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner} 12203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 12303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// SymbolicallyEvaluateGEP - If we can symbolically evaluate the specified GEP 12403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// constant expression, do so. 125f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattnerstatic Constant *SymbolicallyEvaluateGEP(Constant* const* Ops, unsigned NumOps, 12603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner const Type *ResultTy, 127e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context, 12803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner const TargetData *TD) { 12903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner Constant *Ptr = Ops[0]; 130268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (!TD || !cast<PointerType>(Ptr->getType())->getElementType()->isSized()) 13103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return 0; 13203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 133268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner uint64_t BasePtr = 0; 134de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman bool BaseIsInt = true; 135268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (!Ptr->isNullValue()) { 136268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner // If this is a inttoptr from a constant int, we can fold this as the base, 137268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner // otherwise we can't. 138268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) 139268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (CE->getOpcode() == Instruction::IntToPtr) 140268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (ConstantInt *Base = dyn_cast<ConstantInt>(CE->getOperand(0))) 141268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner BasePtr = Base->getZExtValue(); 142268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner 143268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (BasePtr == 0) 144de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman BaseIsInt = false; 14503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 146268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner 147268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner // If this is a constant expr gep that is effectively computing an 148268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner // "offsetof", fold it into 'cast int Size to T*' instead of 'gep 0, 0, 12' 149268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner for (unsigned i = 1; i != NumOps; ++i) 150268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (!isa<ConstantInt>(Ops[i])) 151de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman return 0; 152268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner 153268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner uint64_t Offset = TD->getIndexedOffset(Ptr->getType(), 154268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner (Value**)Ops+1, NumOps-1); 155de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // If the base value for this address is a literal integer value, fold the 156de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // getelementptr to the resulting integer value casted to the pointer type. 157de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman if (BaseIsInt) { 158de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman Constant *C = ConstantInt::get(TD->getIntPtrType(Context), Offset+BasePtr); 159de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman return ConstantExpr::getIntToPtr(C, ResultTy); 160de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman } 161de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman 162de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // Otherwise form a regular getelementptr. Recompute the indices so that 163de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // we eliminate over-indexing of the notional static type array bounds. 164de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // This makes it easy to determine if the getelementptr is "inbounds". 165de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // Also, this helps GlobalOpt do SROA on GlobalVariables. 166de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman const Type *Ty = Ptr->getType(); 167de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman SmallVector<Constant*, 32> NewIdxs; 168de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman for (unsigned Index = 1; Index != NumOps; ++Index) { 169de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman if (const SequentialType *ATy = dyn_cast<SequentialType>(Ty)) { 170de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // Determine which element of the array the offset points into. 171de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman uint64_t ElemSize = TD->getTypeAllocSize(ATy->getElementType()); 172de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman if (ElemSize == 0) 173de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman return 0; 174de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman uint64_t NewIdx = Offset / ElemSize; 175de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman Offset -= NewIdx * ElemSize; 176de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman NewIdxs.push_back(ConstantInt::get(TD->getIntPtrType(Context), NewIdx)); 177de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman Ty = ATy->getElementType(); 178de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 179de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // Determine which field of the struct the offset points into. 180de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman const StructLayout &SL = *TD->getStructLayout(STy); 181de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman unsigned ElIdx = SL.getElementContainingOffset(Offset); 182de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman NewIdxs.push_back(ConstantInt::get(Type::getInt32Ty(Context), ElIdx)); 183de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman Offset -= SL.getElementOffset(ElIdx); 184de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman Ty = STy->getTypeAtIndex(ElIdx); 185de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman } else { 186de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman return 0; 187de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman } 188de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman } 189de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman 190de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // If the base is the start of a GlobalVariable and all the array indices 191de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // remain in their static bounds, the GEP is inbounds. We can check that 192de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // all indices are in bounds by just checking the first index only 193de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // because we've just normalized all the indices. 194de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman if (isa<GlobalVariable>(Ptr) && NewIdxs[0]->isNullValue()) 195de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman return ConstantExpr::getInBoundsGetElementPtr(Ptr, 196de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman &NewIdxs[0], NewIdxs.size()); 197de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman 198de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // Otherwise it may not be inbounds. 199de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman return ConstantExpr::getGetElementPtr(Ptr, &NewIdxs[0], NewIdxs.size()); 20003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner} 20103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 2021afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner/// FoldBitCast - Constant fold bitcast, symbolically evaluating it with 2031afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner/// targetdata. Return 0 if unfoldable. 2041afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattnerstatic Constant *FoldBitCast(Constant *C, const Type *DestTy, 205e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson const TargetData &TD, LLVMContext &Context) { 2061afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // If this is a bitcast from constant vector -> vector, fold it. 2071afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (ConstantVector *CV = dyn_cast<ConstantVector>(C)) { 2081afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (const VectorType *DestVTy = dyn_cast<VectorType>(DestTy)) { 2091afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // If the element types match, VMCore can fold it. 2101afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned NumDstElt = DestVTy->getNumElements(); 2111afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned NumSrcElt = CV->getNumOperands(); 2121afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (NumDstElt == NumSrcElt) 2131afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner return 0; 2141afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2151afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner const Type *SrcEltTy = CV->getType()->getElementType(); 2161afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner const Type *DstEltTy = DestVTy->getElementType(); 2171afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2181afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Otherwise, we're changing the number of elements in a vector, which 2191afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // requires endianness information to do the right thing. For example, 2201afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // bitcast (<2 x i64> <i64 0, i64 1> to <4 x i32>) 2211afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // folds to (little endian): 2221afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // <4 x i32> <i32 0, i32 0, i32 1, i32 0> 2231afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // and to (big endian): 2241afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // <4 x i32> <i32 0, i32 0, i32 0, i32 1> 2251afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2261afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // First thing is first. We only want to think about integer here, so if 2271afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // we have something in FP form, recast it as integer. 2281afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (DstEltTy->isFloatingPoint()) { 2291afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Fold to an vector of integers with same size as our FP type. 2301afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned FPWidth = DstEltTy->getPrimitiveSizeInBits(); 231debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson const Type *DestIVTy = VectorType::get( 2321d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson IntegerType::get(Context, FPWidth), NumDstElt); 2331afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Recursively handle this integer conversion, if possible. 234508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson C = FoldBitCast(C, DestIVTy, TD, Context); 2351afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (!C) return 0; 2361afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2371afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Finally, VMCore can handle this now that #elts line up. 238baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getBitCast(C, DestTy); 2391afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 2401afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2411afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Okay, we know the destination is integer, if the input is FP, convert 2421afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // it to integer first. 2431afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (SrcEltTy->isFloatingPoint()) { 2441afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned FPWidth = SrcEltTy->getPrimitiveSizeInBits(); 245debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson const Type *SrcIVTy = VectorType::get( 2461d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson IntegerType::get(Context, FPWidth), NumSrcElt); 2471afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Ask VMCore to do the conversion now that #elts line up. 248baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson C = ConstantExpr::getBitCast(C, SrcIVTy); 2491afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner CV = dyn_cast<ConstantVector>(C); 2501afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (!CV) return 0; // If VMCore wasn't able to fold it, bail out. 2511afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 2521afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2531afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Now we know that the input and output vectors are both integer vectors 2541afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // of the same size, and that their #elements is not the same. Do the 2551afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // conversion here, which depends on whether the input or output has 2561afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // more elements. 2571afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner bool isLittleEndian = TD.isLittleEndian(); 2581afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2591afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner SmallVector<Constant*, 32> Result; 2601afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (NumDstElt < NumSrcElt) { 2611afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Handle: bitcast (<4 x i32> <i32 0, i32 1, i32 2, i32 3> to <2 x i64>) 262a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson Constant *Zero = Constant::getNullValue(DstEltTy); 2631afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned Ratio = NumSrcElt/NumDstElt; 2641afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned SrcBitSize = SrcEltTy->getPrimitiveSizeInBits(); 2651afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned SrcElt = 0; 2661afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner for (unsigned i = 0; i != NumDstElt; ++i) { 2671afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Build each element of the result. 2681afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner Constant *Elt = Zero; 2691afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned ShiftAmt = isLittleEndian ? 0 : SrcBitSize*(Ratio-1); 2701afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner for (unsigned j = 0; j != Ratio; ++j) { 2711afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner Constant *Src = dyn_cast<ConstantInt>(CV->getOperand(SrcElt++)); 2721afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (!Src) return 0; // Reject constantexpr elements. 2731afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2741afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Zero extend the element to the right size. 275baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Src = ConstantExpr::getZExt(Src, Elt->getType()); 2761afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2771afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Shift it to the right place, depending on endianness. 278baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Src = ConstantExpr::getShl(Src, 279eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantInt::get(Src->getType(), ShiftAmt)); 2801afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner ShiftAmt += isLittleEndian ? SrcBitSize : -SrcBitSize; 2811afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2821afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Mix it in. 283baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Elt = ConstantExpr::getOr(Elt, Src); 2841afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 2851afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner Result.push_back(Elt); 2861afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 2871afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } else { 2881afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Handle: bitcast (<2 x i64> <i64 0, i64 1> to <4 x i32>) 2891afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned Ratio = NumDstElt/NumSrcElt; 2901afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned DstBitSize = DstEltTy->getPrimitiveSizeInBits(); 2911afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2921afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Loop over each source value, expanding into multiple results. 2931afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner for (unsigned i = 0; i != NumSrcElt; ++i) { 2941afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner Constant *Src = dyn_cast<ConstantInt>(CV->getOperand(i)); 2951afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (!Src) return 0; // Reject constantexpr elements. 2961afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2971afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned ShiftAmt = isLittleEndian ? 0 : DstBitSize*(Ratio-1); 2981afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner for (unsigned j = 0; j != Ratio; ++j) { 2991afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Shift the piece of the value into the right place, depending on 3001afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // endianness. 301baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *Elt = ConstantExpr::getLShr(Src, 302eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantInt::get(Src->getType(), ShiftAmt)); 3031afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner ShiftAmt += isLittleEndian ? DstBitSize : -DstBitSize; 3041afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 3051afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Truncate and remember this piece. 306baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Result.push_back(ConstantExpr::getTrunc(Elt, DstEltTy)); 3071afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3081afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3091afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3101afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 311af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson return ConstantVector::get(Result.data(), Result.size()); 3121afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3131afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3141afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 3151afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner return 0; 3161afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner} 3171afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 31803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 31903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner//===----------------------------------------------------------------------===// 32003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner// Constant Folding public APIs 32103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner//===----------------------------------------------------------------------===// 32203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 32303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 3245520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// ConstantFoldInstruction - Attempt to constant fold the specified 3255520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// instruction. If successful, the constant result is returned, if not, null 3265520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// is returned. Note that this function can only fail when attempting to fold 3275520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// instructions like loads and stores, which have no constant expression form. 3285520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// 329e922c0201916e0b980ab3cfe91e1413e68d55647Owen AndersonConstant *llvm::ConstantFoldInstruction(Instruction *I, LLVMContext &Context, 330508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson const TargetData *TD) { 3315520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(I)) { 3325520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (PN->getNumIncomingValues() == 0) 3339e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson return UndefValue::get(PN->getType()); 3345520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 3355520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner Constant *Result = dyn_cast<Constant>(PN->getIncomingValue(0)); 3365520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (Result == 0) return 0; 3375520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 3385520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // Handle PHI nodes specially here... 3395520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner for (unsigned i = 1, e = PN->getNumIncomingValues(); i != e; ++i) 3405520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (PN->getIncomingValue(i) != Result && PN->getIncomingValue(i) != PN) 3415520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; // Not all the same incoming constants... 3425520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 3435520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // If we reach here, all incoming values are the same constant. 3445520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return Result; 3455520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } 3465520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 3475520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // Scan the operand list, checking to see if they are all constants, if so, 3485520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // hand off to ConstantFoldInstOperands. 3495520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner SmallVector<Constant*, 8> Ops; 350de2d74b213844b17eb5327fba27f21e699d3af66Gabor Greif for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i) 351de2d74b213844b17eb5327fba27f21e699d3af66Gabor Greif if (Constant *Op = dyn_cast<Constant>(*i)) 3525520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner Ops.push_back(Op); 3535520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else 3545520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; // All operands not constant! 3555520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 356f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (const CmpInst *CI = dyn_cast<CmpInst>(I)) 357f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner return ConstantFoldCompareInstOperands(CI->getPredicate(), 358508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Ops.data(), Ops.size(), 359508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 360f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner else 361f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner return ConstantFoldInstOperands(I->getOpcode(), I->getType(), 362508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Ops.data(), Ops.size(), Context, TD); 3635520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner} 3645520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 3653dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky/// ConstantFoldConstantExpression - Attempt to fold the constant expression 3663dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky/// using the specified TargetData. If successful, the constant result is 3673dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky/// result is returned, if not, null is returned. 3683dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick LewyckyConstant *llvm::ConstantFoldConstantExpression(ConstantExpr *CE, 369e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context, 3703dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky const TargetData *TD) { 3713dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky SmallVector<Constant*, 8> Ops; 3723dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky for (User::op_iterator i = CE->op_begin(), e = CE->op_end(); i != e; ++i) 3733dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky Ops.push_back(cast<Constant>(*i)); 3743dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky 3753dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky if (CE->isCompare()) 3763dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky return ConstantFoldCompareInstOperands(CE->getPredicate(), 377508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Ops.data(), Ops.size(), 378508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 3793dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky else 3803dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky return ConstantFoldInstOperands(CE->getOpcode(), CE->getType(), 381508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Ops.data(), Ops.size(), Context, TD); 3823dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky} 3833dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky 3845520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// ConstantFoldInstOperands - Attempt to constant fold an instruction with the 3855520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// specified opcode and operands. If successful, the constant result is 3865520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// returned, if not, null is returned. Note that this function can fail when 3875520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// attempting to fold instructions like loads and stores, which have no 3885520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// constant expression form. 3895520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// 390f286f6fd93d569befe6e77c94a947e6e04e95685Chris LattnerConstant *llvm::ConstantFoldInstOperands(unsigned Opcode, const Type *DestTy, 391f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner Constant* const* Ops, unsigned NumOps, 392e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context, 3935520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner const TargetData *TD) { 39403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Handle easy binops first. 395f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (Instruction::isBinaryOp(Opcode)) { 39603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (isa<ConstantExpr>(Ops[0]) || isa<ConstantExpr>(Ops[1])) 397508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson if (Constant *C = SymbolicallyEvaluateBinop(Opcode, Ops[0], Ops[1], TD, 398508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context)) 39903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return C; 40003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 401baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::get(Opcode, Ops[0], Ops[1]); 40203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 4035520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 404f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner switch (Opcode) { 4055520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner default: return 0; 4065520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::Call: 4075520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (Function *F = dyn_cast<Function>(Ops[0])) 4085520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (canConstantFoldCallTo(F)) 409ad58eb34342f70f094008e6d08cb4ed814754e64Chris Lattner return ConstantFoldCall(F, Ops+1, NumOps-1); 4105520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 4115520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::ICmp: 4125520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::FCmp: 413c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("This function is invalid for compares: no predicate specified"); 414001f7534e0311508cc93831a595785bb177f8a18Chris Lattner case Instruction::PtrToInt: 415001f7534e0311508cc93831a595785bb177f8a18Chris Lattner // If the input is a inttoptr, eliminate the pair. This requires knowing 416001f7534e0311508cc93831a595785bb177f8a18Chris Lattner // the width of a pointer, so it can't be done in ConstantExpr::getCast. 417001f7534e0311508cc93831a595785bb177f8a18Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ops[0])) { 418001f7534e0311508cc93831a595785bb177f8a18Chris Lattner if (TD && CE->getOpcode() == Instruction::IntToPtr) { 419001f7534e0311508cc93831a595785bb177f8a18Chris Lattner Constant *Input = CE->getOperand(0); 4206de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman unsigned InWidth = Input->getType()->getScalarSizeInBits(); 42104aa2c3520c049333ca216fb794d700310c4a33dNick Lewycky if (TD->getPointerSizeInBits() < InWidth) { 42204aa2c3520c049333ca216fb794d700310c4a33dNick Lewycky Constant *Mask = 423eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantInt::get(Context, APInt::getLowBitsSet(InWidth, 42404aa2c3520c049333ca216fb794d700310c4a33dNick Lewycky TD->getPointerSizeInBits())); 425baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Input = ConstantExpr::getAnd(Input, Mask); 42604aa2c3520c049333ca216fb794d700310c4a33dNick Lewycky } 427001f7534e0311508cc93831a595785bb177f8a18Chris Lattner // Do a zext or trunc to get to the dest size. 428baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getIntegerCast(Input, DestTy, false); 429001f7534e0311508cc93831a595785bb177f8a18Chris Lattner } 430001f7534e0311508cc93831a595785bb177f8a18Chris Lattner } 431baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getCast(Opcode, Ops[0], DestTy); 432001f7534e0311508cc93831a595785bb177f8a18Chris Lattner case Instruction::IntToPtr: 43381b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands // If the input is a ptrtoint, turn the pair into a ptr to ptr bitcast if 43481b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands // the int size is >= the ptr size. This requires knowing the width of a 43581b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands // pointer, so it can't be done in ConstantExpr::getCast. 43681b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ops[0])) { 4379a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (TD && 43881b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands TD->getPointerSizeInBits() <= 4396de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman CE->getType()->getScalarSizeInBits()) { 4409a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (CE->getOpcode() == Instruction::PtrToInt) { 4419a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman Constant *Input = CE->getOperand(0); 442508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Constant *C = FoldBitCast(Input, DestTy, *TD, Context); 443baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return C ? C : ConstantExpr::getBitCast(Input, DestTy); 4449a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman } 4459a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman // If there's a constant offset added to the integer value before 4469a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman // it is casted back to a pointer, see if the expression can be 4479a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman // converted into a GEP. 4489a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (CE->getOpcode() == Instruction::Add) 4499a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (ConstantInt *L = dyn_cast<ConstantInt>(CE->getOperand(0))) 4509a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (ConstantExpr *R = dyn_cast<ConstantExpr>(CE->getOperand(1))) 4519a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (R->getOpcode() == Instruction::PtrToInt) 4529a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (GlobalVariable *GV = 4539a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman dyn_cast<GlobalVariable>(R->getOperand(0))) { 4549a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman const PointerType *GVTy = cast<PointerType>(GV->getType()); 4559a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (const ArrayType *AT = 4569a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman dyn_cast<ArrayType>(GVTy->getElementType())) { 4579a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman const Type *ElTy = AT->getElementType(); 458777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands uint64_t AllocSize = TD->getTypeAllocSize(ElTy); 459777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands APInt PSA(L->getValue().getBitWidth(), AllocSize); 4609a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (ElTy == cast<PointerType>(DestTy)->getElementType() && 4619a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman L->getValue().urem(PSA) == 0) { 4629a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman APInt ElemIdx = L->getValue().udiv(PSA); 4639a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (ElemIdx.ult(APInt(ElemIdx.getBitWidth(), 4649a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman AT->getNumElements()))) { 4659a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman Constant *Index[] = { 466a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson Constant::getNullValue(CE->getType()), 467eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantInt::get(Context, ElemIdx) 4689a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman }; 469508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return 470baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ConstantExpr::getGetElementPtr(GV, &Index[0], 2); 4719a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman } 4729a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman } 4739a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman } 4749a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman } 47581b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands } 47681b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands } 477baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getCast(Opcode, Ops[0], DestTy); 4785520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::Trunc: 4795520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::ZExt: 4805520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::SExt: 4815520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::FPTrunc: 4825520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::FPExt: 4835520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::UIToFP: 4845520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::SIToFP: 4855520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::FPToUI: 4865520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::FPToSI: 487baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getCast(Opcode, Ops[0], DestTy); 4885520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::BitCast: 4891afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (TD) 490508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson if (Constant *C = FoldBitCast(Ops[0], DestTy, *TD, Context)) 4911afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner return C; 492baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getBitCast(Ops[0], DestTy); 4935520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::Select: 494baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]); 4955520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::ExtractElement: 496baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getExtractElement(Ops[0], Ops[1]); 4975520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::InsertElement: 498baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]); 4995520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::ShuffleVector: 500baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]); 5015520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::GetElementPtr: 502508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson if (Constant *C = SymbolicallyEvaluateGEP(Ops, NumOps, DestTy, Context, TD)) 50303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return C; 50403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 505baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getGetElementPtr(Ops[0], Ops+1, NumOps-1); 5065520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } 5075520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner} 5085520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 509f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner/// ConstantFoldCompareInstOperands - Attempt to constant fold a compare 510f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner/// instruction (icmp/fcmp) with the specified operands. If it fails, it 511f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner/// returns a constant expression of the specified operands. 512f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner/// 513f286f6fd93d569befe6e77c94a947e6e04e95685Chris LattnerConstant *llvm::ConstantFoldCompareInstOperands(unsigned Predicate, 514f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner Constant*const * Ops, 515f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner unsigned NumOps, 516e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context, 517f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner const TargetData *TD) { 518f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // fold: icmp (inttoptr x), null -> icmp x, 0 519f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // fold: icmp (ptrtoint x), 0 -> icmp x, null 5203dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky // fold: icmp (inttoptr x), (inttoptr y) -> icmp trunc/zext x, trunc/zext y 521f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // fold: icmp (ptrtoint x), (ptrtoint y) -> icmp x, y 522f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // 523f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // ConstantExpr::getCompare cannot do this, because it doesn't have TD 524f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // around to know if bit truncation is happening. 525f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (ConstantExpr *CE0 = dyn_cast<ConstantExpr>(Ops[0])) { 526f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (TD && Ops[1]->isNullValue()) { 5271d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson const Type *IntPtrTy = TD->getIntPtrType(Context); 528f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (CE0->getOpcode() == Instruction::IntToPtr) { 529f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // Convert the integer value to the right size to ensure we get the 530f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // proper extension or truncation. 531baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *C = ConstantExpr::getIntegerCast(CE0->getOperand(0), 532f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner IntPtrTy, false); 533a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson Constant *NewOps[] = { C, Constant::getNullValue(C->getType()) }; 534508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldCompareInstOperands(Predicate, NewOps, 2, 535508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 536f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 537f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner 538f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // Only do this transformation if the int is intptrty in size, otherwise 539f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // there is a truncation or extension that we aren't modeling. 540f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (CE0->getOpcode() == Instruction::PtrToInt && 541f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner CE0->getType() == IntPtrTy) { 542f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner Constant *C = CE0->getOperand(0); 543a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson Constant *NewOps[] = { C, Constant::getNullValue(C->getType()) }; 544f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // FIXME! 545508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldCompareInstOperands(Predicate, NewOps, 2, 546508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 547f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 548f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 549f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner 5503dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(Ops[1])) { 5513dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky if (TD && CE0->getOpcode() == CE1->getOpcode()) { 5521d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson const Type *IntPtrTy = TD->getIntPtrType(Context); 5533dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky 5543dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky if (CE0->getOpcode() == Instruction::IntToPtr) { 5553dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky // Convert the integer value to the right size to ensure we get the 5563dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky // proper extension or truncation. 557baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *C0 = ConstantExpr::getIntegerCast(CE0->getOperand(0), 5583dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky IntPtrTy, false); 559baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *C1 = ConstantExpr::getIntegerCast(CE1->getOperand(0), 5603dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky IntPtrTy, false); 5613dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky Constant *NewOps[] = { C0, C1 }; 562508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldCompareInstOperands(Predicate, NewOps, 2, 563508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 5643dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky } 5653dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky 5663dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky // Only do this transformation if the int is intptrty in size, otherwise 5673dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky // there is a truncation or extension that we aren't modeling. 5683dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky if ((CE0->getOpcode() == Instruction::PtrToInt && 5693dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky CE0->getType() == IntPtrTy && 5703dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType())) { 5713dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky Constant *NewOps[] = { 5723dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky CE0->getOperand(0), CE1->getOperand(0) 5733dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky }; 574508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldCompareInstOperands(Predicate, NewOps, 2, 575508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 5763dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky } 577f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 578f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 579f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 580baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getCompare(Predicate, Ops[0], Ops[1]); 581f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner} 582f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner 583f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner 5845520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a 5855520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// getelementptr constantexpr, return the constant value being addressed by the 5865520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// constant expression, or null if something is funny and we can't decide. 5875520732b24a5a321140dd79af70d321c7ff3dec9Chris LattnerConstant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C, 588508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson ConstantExpr *CE, 589e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context) { 590a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson if (CE->getOperand(1) != Constant::getNullValue(CE->getOperand(1)->getType())) 5915520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; // Do not allow stepping over the value! 5925520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 5935520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // Loop over all of the operands, tracking down which value we are 5945520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // addressing... 5955520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner gep_type_iterator I = gep_type_begin(CE), E = gep_type_end(CE); 5965520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner for (++I; I != E; ++I) 5975520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (const StructType *STy = dyn_cast<StructType>(*I)) { 5985520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner ConstantInt *CU = cast<ConstantInt>(I.getOperand()); 5995520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner assert(CU->getZExtValue() < STy->getNumElements() && 6005520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner "Struct index out of range!"); 6015520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner unsigned El = (unsigned)CU->getZExtValue(); 6025520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (ConstantStruct *CS = dyn_cast<ConstantStruct>(C)) { 6035520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner C = CS->getOperand(El); 6045520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else if (isa<ConstantAggregateZero>(C)) { 605a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson C = Constant::getNullValue(STy->getElementType(El)); 6065520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else if (isa<UndefValue>(C)) { 6079e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson C = UndefValue::get(STy->getElementType(El)); 6085520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else { 6095520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6105520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } 6115520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else if (ConstantInt *CI = dyn_cast<ConstantInt>(I.getOperand())) { 6125520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (const ArrayType *ATy = dyn_cast<ArrayType>(*I)) { 6135520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (CI->getZExtValue() >= ATy->getNumElements()) 6145520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6155520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (ConstantArray *CA = dyn_cast<ConstantArray>(C)) 6165520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner C = CA->getOperand(CI->getZExtValue()); 6175520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else if (isa<ConstantAggregateZero>(C)) 618a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson C = Constant::getNullValue(ATy->getElementType()); 6195520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else if (isa<UndefValue>(C)) 6209e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson C = UndefValue::get(ATy->getElementType()); 6215520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else 6225520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6239d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer } else if (const VectorType *PTy = dyn_cast<VectorType>(*I)) { 6245520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (CI->getZExtValue() >= PTy->getNumElements()) 6255520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6269d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (ConstantVector *CP = dyn_cast<ConstantVector>(C)) 6275520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner C = CP->getOperand(CI->getZExtValue()); 6285520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else if (isa<ConstantAggregateZero>(C)) 629a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson C = Constant::getNullValue(PTy->getElementType()); 6305520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else if (isa<UndefValue>(C)) 6319e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson C = UndefValue::get(PTy->getElementType()); 6325520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else 6335520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6345520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else { 6355520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6365520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } 6375520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else { 6385520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6395520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } 6405520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return C; 6415520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner} 6425520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 6435520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 644bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell//===----------------------------------------------------------------------===// 6455520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner// Constant Folding for Calls 646bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell// 647bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 648bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell/// canConstantFoldCallTo - Return true if its even possible to fold a call to 649bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell/// the specified function. 650bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswellbool 651fa9b80eb64127b3d9691e18537975635520e51e9Dan Gohmanllvm::canConstantFoldCallTo(const Function *F) { 652bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell switch (F->getIntrinsicID()) { 6539ab7fb3ba47442d521a5bed09a27a5e8e7a786edDale Johannesen case Intrinsic::sqrt: 6549ab7fb3ba47442d521a5bed09a27a5e8e7a786edDale Johannesen case Intrinsic::powi: 655e9391fd9b52e93717b365bdd05c471101323a4dfReid Spencer case Intrinsic::bswap: 656e9391fd9b52e93717b365bdd05c471101323a4dfReid Spencer case Intrinsic::ctpop: 657e9391fd9b52e93717b365bdd05c471101323a4dfReid Spencer case Intrinsic::ctlz: 658e9391fd9b52e93717b365bdd05c471101323a4dfReid Spencer case Intrinsic::cttz: 659bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell return true; 660bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell default: break; 661bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 662bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 6636f532a988e5c02fcb271fb65e9e7b83f0147d3f2Chris Lattner if (!F->hasName()) return false; 664f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar StringRef Name = F->getName(); 665c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner 666c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner // In these cases, the check of the length is required. We don't want to 667c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner // return true for a name like "cos\0blah" which strcmp would return equal to 668c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner // "cos", but has length 8. 669f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar switch (Name[0]) { 670c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner default: return false; 671c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'a': 672f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "acos" || Name == "asin" || 673f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar Name == "atan" || Name == "atan2"; 674c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'c': 675f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "cos" || Name == "ceil" || Name == "cosf" || Name == "cosh"; 676c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'e': 677f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "exp"; 678c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'f': 679f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "fabs" || Name == "fmod" || Name == "floor"; 680c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'l': 681f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "log" || Name == "log10"; 682c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'p': 683f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "pow"; 684c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 's': 685f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "sin" || Name == "sinh" || Name == "sqrt" || 686f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar Name == "sinf" || Name == "sqrtf"; 687c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 't': 688f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "tan" || Name == "tanh"; 689bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 690bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell} 691bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 69272d88ae5447a3929c97e88f4c806213847b5d988Chris Lattnerstatic Constant *ConstantFoldFP(double (*NativeFP)(double), double V, 693e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson const Type *Ty, LLVMContext &Context) { 694bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell errno = 0; 695bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell V = NativeFP(V); 696f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner if (errno != 0) { 697f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner errno = 0; 698f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner return 0; 69943421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen } 700f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner 7011d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson if (Ty == Type::getFloatTy(Context)) 7026f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat((float)V)); 7031d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson if (Ty == Type::getDoubleTy(Context)) 7046f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat(V)); 705c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Can only constant fold float/double"); 70633e456d5f3909e0c7b96e04e5674c25a182da100Gabor Greif return 0; // dummy return to suppress warning 707bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell} 708bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 709384152444d22d356f7b4090a158da4cbc1f79464Dan Gohmanstatic Constant *ConstantFoldBinaryFP(double (*NativeFP)(double, double), 710384152444d22d356f7b4090a158da4cbc1f79464Dan Gohman double V, double W, 711508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson const Type *Ty, 712e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context) { 713384152444d22d356f7b4090a158da4cbc1f79464Dan Gohman errno = 0; 714384152444d22d356f7b4090a158da4cbc1f79464Dan Gohman V = NativeFP(V, W); 715f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner if (errno != 0) { 716f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner errno = 0; 717f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner return 0; 71843421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen } 719f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner 7201d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson if (Ty == Type::getFloatTy(Context)) 7216f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat((float)V)); 7221d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson if (Ty == Type::getDoubleTy(Context)) 7236f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat(V)); 724c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Can only constant fold float/double"); 72533e456d5f3909e0c7b96e04e5674c25a182da100Gabor Greif return 0; // dummy return to suppress warning 726384152444d22d356f7b4090a158da4cbc1f79464Dan Gohman} 727384152444d22d356f7b4090a158da4cbc1f79464Dan Gohman 728bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell/// ConstantFoldCall - Attempt to constant fold a call to the specified function 729bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell/// with the specified arguments, returning null if unsuccessful. 73043421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen 731bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John CriswellConstant * 732f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattnerllvm::ConstantFoldCall(Function *F, 733f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner Constant* const* Operands, unsigned NumOperands) { 7346f532a988e5c02fcb271fb65e9e7b83f0147d3f2Chris Lattner if (!F->hasName()) return 0; 735e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context = F->getContext(); 736f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar StringRef Name = F->getName(); 737c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner 738bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell const Type *Ty = F->getReturnType(); 73972d88ae5447a3929c97e88f4c806213847b5d988Chris Lattner if (NumOperands == 1) { 740bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell if (ConstantFP *Op = dyn_cast<ConstantFP>(Operands[0])) { 7411d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson if (Ty!=Type::getFloatTy(F->getContext()) && 7421d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Ty!=Type::getDoubleTy(Context)) 74343421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen return 0; 74443421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen /// Currently APFloat versions of these functions do not exist, so we use 74543421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen /// the host native double versions. Float versions are not called 74643421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen /// directly but for all these it is true (float)(f((double)arg)) == 74743421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen /// f(arg). Long double not supported yet. 7481d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson double V = Ty==Type::getFloatTy(F->getContext()) ? 7491d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson (double)Op->getValueAPF().convertToFloat(): 75043421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen Op->getValueAPF().convertToDouble(); 751f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar switch (Name[0]) { 752c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'a': 753f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "acos") 754508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(acos, V, Ty, Context); 755f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "asin") 756508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(asin, V, Ty, Context); 757f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "atan") 758508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(atan, V, Ty, Context); 759c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 760c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'c': 761f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "ceil") 762508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(ceil, V, Ty, Context); 763f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "cos") 764508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(cos, V, Ty, Context); 765f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "cosh") 766508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(cosh, V, Ty, Context); 767f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "cosf") 768508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(cos, V, Ty, Context); 769c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 770c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'e': 771f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "exp") 772508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(exp, V, Ty, Context); 773c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 774c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'f': 775f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "fabs") 776508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(fabs, V, Ty, Context); 777f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "floor") 778508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(floor, V, Ty, Context); 779c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 780c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'l': 781f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "log" && V > 0) 782508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(log, V, Ty, Context); 783f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "log10" && V > 0) 784508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(log10, V, Ty, Context); 785f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "llvm.sqrt.f32" || 786f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar Name == "llvm.sqrt.f64") { 787c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner if (V >= -0.0) 788508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sqrt, V, Ty, Context); 789c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner else // Undefined 790a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return Constant::getNullValue(Ty); 791c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner } 792c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 793c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 's': 794f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "sin") 795508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sin, V, Ty, Context); 796f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "sinh") 797508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sinh, V, Ty, Context); 798f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "sqrt" && V >= 0) 799508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sqrt, V, Ty, Context); 800f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "sqrtf" && V >= 0) 801508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sqrt, V, Ty, Context); 802f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "sinf") 803508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sin, V, Ty, Context); 804c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 805c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 't': 806f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "tan") 807508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(tan, V, Ty, Context); 808f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "tanh") 809508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(tanh, V, Ty, Context); 810c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 811c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner default: 812c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 813bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 814b83eb6447ba155342598f0fabe1f08f5baa9164aReid Spencer } else if (ConstantInt *Op = dyn_cast<ConstantInt>(Operands[0])) { 815f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name.startswith("llvm.bswap")) 816eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return ConstantInt::get(Context, Op->getValue().byteSwap()); 817f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name.startswith("llvm.ctpop")) 818eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return ConstantInt::get(Ty, Op->getValue().countPopulation()); 819f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name.startswith("llvm.cttz")) 820eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return ConstantInt::get(Ty, Op->getValue().countTrailingZeros()); 821f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name.startswith("llvm.ctlz")) 822eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return ConstantInt::get(Ty, Op->getValue().countLeadingZeros()); 823bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 82472d88ae5447a3929c97e88f4c806213847b5d988Chris Lattner } else if (NumOperands == 2) { 825bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell if (ConstantFP *Op1 = dyn_cast<ConstantFP>(Operands[0])) { 8261d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson if (Ty!=Type::getFloatTy(F->getContext()) && 8271d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Ty!=Type::getDoubleTy(Context)) 8289ab7fb3ba47442d521a5bed09a27a5e8e7a786edDale Johannesen return 0; 8291d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson double Op1V = Ty==Type::getFloatTy(F->getContext()) ? 83043421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen (double)Op1->getValueAPF().convertToFloat(): 83143421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen Op1->getValueAPF().convertToDouble(); 832bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell if (ConstantFP *Op2 = dyn_cast<ConstantFP>(Operands[1])) { 8331d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson double Op2V = Ty==Type::getFloatTy(F->getContext()) ? 83443421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen (double)Op2->getValueAPF().convertToFloat(): 83543421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen Op2->getValueAPF().convertToDouble(); 836bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 837f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "pow") { 838508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty, Context); 839f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar } else if (Name == "fmod") { 840508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldBinaryFP(fmod, Op1V, Op2V, Ty, Context); 841f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar } else if (Name == "atan2") { 842508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty, Context); 843b5282dcf4745be59046f440980a1c0f0a50c9c09Chris Lattner } 844b5282dcf4745be59046f440980a1c0f0a50c9c09Chris Lattner } else if (ConstantInt *Op2C = dyn_cast<ConstantInt>(Operands[1])) { 845f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "llvm.powi.f32") { 8466f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat((float)std::pow((float)Op1V, 84702a260aa11a2e1b2c14335274d3c42ca3f3eabc0Chris Lattner (int)Op2C->getZExtValue()))); 848f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar } else if (Name == "llvm.powi.f64") { 8496f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat((double)std::pow((double)Op1V, 85002a260aa11a2e1b2c14335274d3c42ca3f3eabc0Chris Lattner (int)Op2C->getZExtValue()))); 851b5282dcf4745be59046f440980a1c0f0a50c9c09Chris Lattner } 852bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 853bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 854bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 855bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell return 0; 856bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell} 857bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 858