ConstantFolding.cpp revision d0806a1519f3bc450d2dea3e6f22db73fc797e4c
183e3c4f9d796a5da223a3ebd5d4ba985c7ecc39dDan Gohman//===-- ConstantFolding.cpp - Fold instructions into constants ------------===// 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// 1083e3c4f9d796a5da223a3ebd5d4ba985c7ecc39dDan Gohman// This file defines routines for folding instructions into constants. 1183e3c4f9d796a5da223a3ebd5d4ba985c7ecc39dDan Gohman// 1283e3c4f9d796a5da223a3ebd5d4ba985c7ecc39dDan Gohman// Also, to supplement the basic VMCore ConstantExpr simplifications, 1383e3c4f9d796a5da223a3ebd5d4ba985c7ecc39dDan Gohman// this file defines some additional folding routines that can make use of 1483e3c4f9d796a5da223a3ebd5d4ba985c7ecc39dDan Gohman// TargetData information. These functions cannot go in VMCore due to library 1583e3c4f9d796a5da223a3ebd5d4ba985c7ecc39dDan Gohman// dependency issues. 16bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell// 17bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell//===----------------------------------------------------------------------===// 18bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 19bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Analysis/ConstantFolding.h" 20bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Constants.h" 21bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/DerivedTypes.h" 225520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner#include "llvm/Function.h" 239a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman#include "llvm/GlobalVariable.h" 24bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Instructions.h" 25bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Intrinsics.h" 26508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson#include "llvm/LLVMContext.h" 275520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner#include "llvm/ADT/SmallVector.h" 28c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner#include "llvm/ADT/StringMap.h" 2903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner#include "llvm/Target/TargetData.h" 30c25e7581b9b8088910da31702d4ca21c4734c6d7Torok Edwin#include "llvm/Support/ErrorHandling.h" 31bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Support/GetElementPtrTypeIterator.h" 32bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include "llvm/Support/MathExtras.h" 33bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell#include <cerrno> 3497af751deb9b26fd42fbcee082da9ccc4ded5b45Jeff Cohen#include <cmath> 35bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswellusing namespace llvm; 36bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 3703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner//===----------------------------------------------------------------------===// 3803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner// Constant Folding internal helper functions 3903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner//===----------------------------------------------------------------------===// 4003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 4103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// IsConstantOffsetFromGlobal - If this constant is actually a constant offset 4203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// from a global, return the global and the constant. Because of 4303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// constantexprs, this function is recursive. 4403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattnerstatic bool IsConstantOffsetFromGlobal(Constant *C, GlobalValue *&GV, 4503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner int64_t &Offset, const TargetData &TD) { 4603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Trivial case, constant is the global. 4703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if ((GV = dyn_cast<GlobalValue>(C))) { 4803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner Offset = 0; 4903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return true; 5003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 5103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 5203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Otherwise, if this isn't a constant expr, bail out. 5303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner ConstantExpr *CE = dyn_cast<ConstantExpr>(C); 5403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (!CE) return false; 5503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 5603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Look through ptr->int and ptr->ptr casts. 5703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (CE->getOpcode() == Instruction::PtrToInt || 5803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner CE->getOpcode() == Instruction::BitCast) 5903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return IsConstantOffsetFromGlobal(CE->getOperand(0), GV, Offset, TD); 6003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 6103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // i32* getelementptr ([5 x i32]* @a, i32 0, i32 5) 6203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (CE->getOpcode() == Instruction::GetElementPtr) { 6303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Cannot compute this if the element type of the pointer is missing size 6403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // info. 65f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (!cast<PointerType>(CE->getOperand(0)->getType()) 66f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner ->getElementType()->isSized()) 6703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return false; 6803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 6903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // If the base isn't a global+constant, we aren't either. 7003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (!IsConstantOffsetFromGlobal(CE->getOperand(0), GV, Offset, TD)) 7103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return false; 7203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 7303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Otherwise, add any offset that our operands provide. 7403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner gep_type_iterator GTI = gep_type_begin(CE); 75de2d74b213844b17eb5327fba27f21e699d3af66Gabor Greif for (User::const_op_iterator i = CE->op_begin() + 1, e = CE->op_end(); 76785c6af9797fcf551feef70f2ecb5cd075b6e3c4Gabor Greif i != e; ++i, ++GTI) { 77de2d74b213844b17eb5327fba27f21e699d3af66Gabor Greif ConstantInt *CI = dyn_cast<ConstantInt>(*i); 7803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (!CI) return false; // Index isn't a simple constant? 7903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (CI->getZExtValue() == 0) continue; // Not adding anything. 8003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 8103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (const StructType *ST = dyn_cast<StructType>(*GTI)) { 8203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // N = N + Offset 83b1919e2f08ecb37140af676fd2916f8d5ed7df3dChris Lattner Offset += TD.getStructLayout(ST)->getElementOffset(CI->getZExtValue()); 8403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } else { 85ca5183d445954a9b2a570d6bbba1bc2b00ad6442Jeff Cohen const SequentialType *SQT = cast<SequentialType>(*GTI); 86777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands Offset += TD.getTypeAllocSize(SQT->getElementType())*CI->getSExtValue(); 8703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 8803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 8903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return true; 9003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 9103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 9203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return false; 9303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner} 9403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 9503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 9603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// SymbolicallyEvaluateBinop - One of Op0/Op1 is a constant expression. 9767e3566d8f6875e9c92d224f493023408a66227eNick Lewycky/// Attempt to symbolically evaluate the result of a binary operator merging 9803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// these together. If target data info is available, it is provided as TD, 9903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// otherwise TD is null. 10003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattnerstatic Constant *SymbolicallyEvaluateBinop(unsigned Opc, Constant *Op0, 101508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Constant *Op1, const TargetData *TD, 102e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context){ 10303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // SROA 10403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 10503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Fold (and 0xffffffff00000000, (shl x, 32)) -> shl. 10603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Fold (lshr (or X, Y), 32) -> (lshr [X/Y], 32) if one doesn't contribute 10703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // bits. 10803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 10903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 11003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // If the constant expr is something like &A[123] - &A[4].f, fold this into a 11103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // constant. This happens frequently when iterating over a global array. 11203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (Opc == Instruction::Sub && TD) { 11303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner GlobalValue *GV1, *GV2; 11403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner int64_t Offs1, Offs2; 11503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 11603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (IsConstantOffsetFromGlobal(Op0, GV1, Offs1, *TD)) 11703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (IsConstantOffsetFromGlobal(Op1, GV2, Offs2, *TD) && 11803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner GV1 == GV2) { 11903dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // (&GV+C1) - (&GV+C2) -> C1-C2, pointer arithmetic cannot overflow. 120eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return ConstantInt::get(Op0->getType(), Offs1-Offs2); 12103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 12203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 12303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 12403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return 0; 12503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner} 12603dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 12703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// SymbolicallyEvaluateGEP - If we can symbolically evaluate the specified GEP 12803dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner/// constant expression, do so. 129f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattnerstatic Constant *SymbolicallyEvaluateGEP(Constant* const* Ops, unsigned NumOps, 13003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner const Type *ResultTy, 131e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context, 13203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner const TargetData *TD) { 13303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner Constant *Ptr = Ops[0]; 134268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (!TD || !cast<PointerType>(Ptr->getType())->getElementType()->isSized()) 13503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return 0; 136cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman 137cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman unsigned BitWidth = TD->getTypeSizeInBits(TD->getIntPtrType(Context)); 138cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman APInt BasePtr(BitWidth, 0); 139de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman bool BaseIsInt = true; 140268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (!Ptr->isNullValue()) { 141268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner // If this is a inttoptr from a constant int, we can fold this as the base, 142268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner // otherwise we can't. 143268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ptr)) 144268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (CE->getOpcode() == Instruction::IntToPtr) 1457178010a168a378df5d9be95956093a3e5f963fdDan Gohman if (ConstantInt *Base = dyn_cast<ConstantInt>(CE->getOperand(0))) { 146cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman BasePtr = Base->getValue(); 1477178010a168a378df5d9be95956093a3e5f963fdDan Gohman BasePtr.zextOrTrunc(BitWidth); 1487178010a168a378df5d9be95956093a3e5f963fdDan Gohman } 149268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner 150268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (BasePtr == 0) 151de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman BaseIsInt = false; 15203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 153268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner 154268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner // If this is a constant expr gep that is effectively computing an 155268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner // "offsetof", fold it into 'cast int Size to T*' instead of 'gep 0, 0, 12' 156268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner for (unsigned i = 1; i != NumOps; ++i) 157268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner if (!isa<ConstantInt>(Ops[i])) 158de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman return 0; 159268e7d7a9446bb89b80472cdb7b9803f16c0191eChris Lattner 160cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman APInt Offset = APInt(BitWidth, 161cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman TD->getIndexedOffset(Ptr->getType(), 162cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman (Value**)Ops+1, NumOps-1)); 163de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // If the base value for this address is a literal integer value, fold the 164de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // getelementptr to the resulting integer value casted to the pointer type. 165de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman if (BaseIsInt) { 166cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman Constant *C = ConstantInt::get(Context, Offset+BasePtr); 167de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman return ConstantExpr::getIntToPtr(C, ResultTy); 168de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman } 169de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman 170de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // Otherwise form a regular getelementptr. Recompute the indices so that 171de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // we eliminate over-indexing of the notional static type array bounds. 172de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // This makes it easy to determine if the getelementptr is "inbounds". 173de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // Also, this helps GlobalOpt do SROA on GlobalVariables. 174de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman const Type *Ty = Ptr->getType(); 175de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman SmallVector<Constant*, 32> NewIdxs; 1763d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman do { 177de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman if (const SequentialType *ATy = dyn_cast<SequentialType>(Ty)) { 1783d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman // The only pointer indexing we'll do is on the first index of the GEP. 179f19f9347b85279100f7d549154e37b6d726c3c94Chris Lattner if (isa<PointerType>(ATy) && !NewIdxs.empty()) 1803d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman break; 181de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman // Determine which element of the array the offset points into. 182cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman APInt ElemSize(BitWidth, TD->getTypeAllocSize(ATy->getElementType())); 183de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman if (ElemSize == 0) 184de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman return 0; 185cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman APInt NewIdx = Offset.udiv(ElemSize); 186de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman Offset -= NewIdx * ElemSize; 187de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman NewIdxs.push_back(ConstantInt::get(TD->getIntPtrType(Context), NewIdx)); 188de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman Ty = ATy->getElementType(); 189de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman } else if (const StructType *STy = dyn_cast<StructType>(Ty)) { 190cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman // Determine which field of the struct the offset points into. The 191cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman // getZExtValue is at least as safe as the StructLayout API because we 192cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman // know the offset is within the struct at this point. 193de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman const StructLayout &SL = *TD->getStructLayout(STy); 194cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman unsigned ElIdx = SL.getElementContainingOffset(Offset.getZExtValue()); 195de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman NewIdxs.push_back(ConstantInt::get(Type::getInt32Ty(Context), ElIdx)); 196cda9706cb74a65d2feb2175613cb0fe46acc5aa2Dan Gohman Offset -= APInt(BitWidth, SL.getElementOffset(ElIdx)); 197de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman Ty = STy->getTypeAtIndex(ElIdx); 198de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman } else { 1993d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman // We've reached some non-indexable type. 2003d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman break; 201de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman } 2023d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman } while (Ty != cast<PointerType>(ResultTy)->getElementType()); 2033d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman 2043d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman // If we haven't used up the entire offset by descending the static 2053d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman // type, then the offset is pointing into the middle of an indivisible 2063d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman // member, so we can't simplify it. 2073d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman if (Offset != 0) 2083d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman return 0; 209de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman 2103bfbc4587a7e79f08f8c126a9e62c3475fb90f8bDan Gohman // Create a GEP. 2113bfbc4587a7e79f08f8c126a9e62c3475fb90f8bDan Gohman Constant *C = 2126e7ad958683f34bf6c014c88fef723e5a2d741beDan Gohman ConstantExpr::getGetElementPtr(Ptr, &NewIdxs[0], NewIdxs.size()); 2136e7ad958683f34bf6c014c88fef723e5a2d741beDan Gohman assert(cast<PointerType>(C->getType())->getElementType() == Ty && 2146e7ad958683f34bf6c014c88fef723e5a2d741beDan Gohman "Computed GetElementPtr has unexpected type!"); 2153d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman 2163d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman // If we ended up indexing a member with a type that doesn't match 2174c0d5d5db876b0628bdf6a2174263a1c0a9130e2Dan Gohman // the type of what the original indices indexed, add a cast. 2183d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman if (Ty != cast<PointerType>(ResultTy)->getElementType()) 2193d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman C = ConstantExpr::getBitCast(C, ResultTy); 220de0e587e63f71afb2ac53c9880c262089fe798bbDan Gohman 2213d01334e6fa5caba1361d088fabf728c64b23c58Dan Gohman return C; 22203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner} 22303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 2241afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner/// FoldBitCast - Constant fold bitcast, symbolically evaluating it with 2251afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner/// targetdata. Return 0 if unfoldable. 2261afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattnerstatic Constant *FoldBitCast(Constant *C, const Type *DestTy, 227e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson const TargetData &TD, LLVMContext &Context) { 2281afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // If this is a bitcast from constant vector -> vector, fold it. 2291afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (ConstantVector *CV = dyn_cast<ConstantVector>(C)) { 2301afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (const VectorType *DestVTy = dyn_cast<VectorType>(DestTy)) { 2311afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // If the element types match, VMCore can fold it. 2321afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned NumDstElt = DestVTy->getNumElements(); 2331afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned NumSrcElt = CV->getNumOperands(); 2341afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (NumDstElt == NumSrcElt) 2351afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner return 0; 2361afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2371afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner const Type *SrcEltTy = CV->getType()->getElementType(); 2381afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner const Type *DstEltTy = DestVTy->getElementType(); 2391afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2401afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Otherwise, we're changing the number of elements in a vector, which 2411afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // requires endianness information to do the right thing. For example, 2421afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // bitcast (<2 x i64> <i64 0, i64 1> to <4 x i32>) 2431afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // folds to (little endian): 2441afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // <4 x i32> <i32 0, i32 0, i32 1, i32 0> 2451afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // and to (big endian): 2461afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // <4 x i32> <i32 0, i32 0, i32 0, i32 1> 2471afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2481afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // First thing is first. We only want to think about integer here, so if 2491afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // we have something in FP form, recast it as integer. 2501afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (DstEltTy->isFloatingPoint()) { 2511afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Fold to an vector of integers with same size as our FP type. 2521afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned FPWidth = DstEltTy->getPrimitiveSizeInBits(); 253debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson const Type *DestIVTy = VectorType::get( 2541d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson IntegerType::get(Context, FPWidth), NumDstElt); 2551afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Recursively handle this integer conversion, if possible. 256508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson C = FoldBitCast(C, DestIVTy, TD, Context); 2571afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (!C) return 0; 2581afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2591afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Finally, VMCore can handle this now that #elts line up. 260baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getBitCast(C, DestTy); 2611afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 2621afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2631afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Okay, we know the destination is integer, if the input is FP, convert 2641afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // it to integer first. 2651afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (SrcEltTy->isFloatingPoint()) { 2661afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned FPWidth = SrcEltTy->getPrimitiveSizeInBits(); 267debcb01b0f0a15f568ca69e8f288fade4bfc7297Owen Anderson const Type *SrcIVTy = VectorType::get( 2681d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson IntegerType::get(Context, FPWidth), NumSrcElt); 2691afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Ask VMCore to do the conversion now that #elts line up. 270baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson C = ConstantExpr::getBitCast(C, SrcIVTy); 2711afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner CV = dyn_cast<ConstantVector>(C); 2721afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (!CV) return 0; // If VMCore wasn't able to fold it, bail out. 2731afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 2741afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2751afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Now we know that the input and output vectors are both integer vectors 2761afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // of the same size, and that their #elements is not the same. Do the 2771afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // conversion here, which depends on whether the input or output has 2781afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // more elements. 2791afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner bool isLittleEndian = TD.isLittleEndian(); 2801afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2811afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner SmallVector<Constant*, 32> Result; 2821afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (NumDstElt < NumSrcElt) { 2831afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Handle: bitcast (<4 x i32> <i32 0, i32 1, i32 2, i32 3> to <2 x i64>) 284a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson Constant *Zero = Constant::getNullValue(DstEltTy); 2851afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned Ratio = NumSrcElt/NumDstElt; 2861afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned SrcBitSize = SrcEltTy->getPrimitiveSizeInBits(); 2871afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned SrcElt = 0; 2881afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner for (unsigned i = 0; i != NumDstElt; ++i) { 2891afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Build each element of the result. 2901afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner Constant *Elt = Zero; 2911afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned ShiftAmt = isLittleEndian ? 0 : SrcBitSize*(Ratio-1); 2921afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner for (unsigned j = 0; j != Ratio; ++j) { 2931afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner Constant *Src = dyn_cast<ConstantInt>(CV->getOperand(SrcElt++)); 2941afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (!Src) return 0; // Reject constantexpr elements. 2951afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2961afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Zero extend the element to the right size. 297baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Src = ConstantExpr::getZExt(Src, Elt->getType()); 2981afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 2991afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Shift it to the right place, depending on endianness. 300baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Src = ConstantExpr::getShl(Src, 301eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantInt::get(Src->getType(), ShiftAmt)); 3021afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner ShiftAmt += isLittleEndian ? SrcBitSize : -SrcBitSize; 3031afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 3041afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Mix it in. 305baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Elt = ConstantExpr::getOr(Elt, Src); 3061afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3071afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner Result.push_back(Elt); 3081afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3091afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } else { 3101afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Handle: bitcast (<2 x i64> <i64 0, i64 1> to <4 x i32>) 3111afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned Ratio = NumDstElt/NumSrcElt; 3121afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned DstBitSize = DstEltTy->getPrimitiveSizeInBits(); 3131afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 3141afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Loop over each source value, expanding into multiple results. 3151afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner for (unsigned i = 0; i != NumSrcElt; ++i) { 3161afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner Constant *Src = dyn_cast<ConstantInt>(CV->getOperand(i)); 3171afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (!Src) return 0; // Reject constantexpr elements. 3181afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 3191afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner unsigned ShiftAmt = isLittleEndian ? 0 : DstBitSize*(Ratio-1); 3201afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner for (unsigned j = 0; j != Ratio; ++j) { 3211afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Shift the piece of the value into the right place, depending on 3221afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // endianness. 323baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *Elt = ConstantExpr::getLShr(Src, 324eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantInt::get(Src->getType(), ShiftAmt)); 3251afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner ShiftAmt += isLittleEndian ? DstBitSize : -DstBitSize; 3261afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 3271afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner // Truncate and remember this piece. 328baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Result.push_back(ConstantExpr::getTrunc(Elt, DstEltTy)); 3291afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3301afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3311afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3321afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 333af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson return ConstantVector::get(Result.data(), Result.size()); 3341afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3351afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner } 3361afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 3371afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner return 0; 3381afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner} 3391afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner 34003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 34103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner//===----------------------------------------------------------------------===// 34203dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner// Constant Folding public APIs 34303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner//===----------------------------------------------------------------------===// 34403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 34503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 3465520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// ConstantFoldInstruction - Attempt to constant fold the specified 3475520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// instruction. If successful, the constant result is returned, if not, null 3485520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// is returned. Note that this function can only fail when attempting to fold 3495520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// instructions like loads and stores, which have no constant expression form. 3505520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// 351e922c0201916e0b980ab3cfe91e1413e68d55647Owen AndersonConstant *llvm::ConstantFoldInstruction(Instruction *I, LLVMContext &Context, 352508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson const TargetData *TD) { 3535520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (PHINode *PN = dyn_cast<PHINode>(I)) { 3545520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (PN->getNumIncomingValues() == 0) 3559e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson return UndefValue::get(PN->getType()); 3565520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 3575520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner Constant *Result = dyn_cast<Constant>(PN->getIncomingValue(0)); 3585520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (Result == 0) return 0; 3595520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 3605520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // Handle PHI nodes specially here... 3615520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner for (unsigned i = 1, e = PN->getNumIncomingValues(); i != e; ++i) 3625520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (PN->getIncomingValue(i) != Result && PN->getIncomingValue(i) != PN) 3635520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; // Not all the same incoming constants... 3645520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 3655520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // If we reach here, all incoming values are the same constant. 3665520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return Result; 3675520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } 3685520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 3695520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // Scan the operand list, checking to see if they are all constants, if so, 3705520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // hand off to ConstantFoldInstOperands. 3715520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner SmallVector<Constant*, 8> Ops; 372de2d74b213844b17eb5327fba27f21e699d3af66Gabor Greif for (User::op_iterator i = I->op_begin(), e = I->op_end(); i != e; ++i) 373de2d74b213844b17eb5327fba27f21e699d3af66Gabor Greif if (Constant *Op = dyn_cast<Constant>(*i)) 3745520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner Ops.push_back(Op); 3755520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else 3765520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; // All operands not constant! 3775520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 378f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (const CmpInst *CI = dyn_cast<CmpInst>(I)) 379f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner return ConstantFoldCompareInstOperands(CI->getPredicate(), 380508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Ops.data(), Ops.size(), 381508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 38258665d47aea69875c433fb039c8f10106abc1ceeChris Lattner 38358665d47aea69875c433fb039c8f10106abc1ceeChris Lattner return ConstantFoldInstOperands(I->getOpcode(), I->getType(), 38458665d47aea69875c433fb039c8f10106abc1ceeChris Lattner Ops.data(), Ops.size(), Context, TD); 3855520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner} 3865520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 3873dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky/// ConstantFoldConstantExpression - Attempt to fold the constant expression 3883dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky/// using the specified TargetData. If successful, the constant result is 3893dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky/// result is returned, if not, null is returned. 3903dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick LewyckyConstant *llvm::ConstantFoldConstantExpression(ConstantExpr *CE, 391e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context, 3923dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky const TargetData *TD) { 3933dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky SmallVector<Constant*, 8> Ops; 3943dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky for (User::op_iterator i = CE->op_begin(), e = CE->op_end(); i != e; ++i) 3953dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky Ops.push_back(cast<Constant>(*i)); 3963dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky 3973dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky if (CE->isCompare()) 3983dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky return ConstantFoldCompareInstOperands(CE->getPredicate(), 399508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Ops.data(), Ops.size(), 400508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 40158665d47aea69875c433fb039c8f10106abc1ceeChris Lattner return ConstantFoldInstOperands(CE->getOpcode(), CE->getType(), 40258665d47aea69875c433fb039c8f10106abc1ceeChris Lattner Ops.data(), Ops.size(), Context, TD); 4033dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky} 4043dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky 4055520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// ConstantFoldInstOperands - Attempt to constant fold an instruction with the 4065520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// specified opcode and operands. If successful, the constant result is 4075520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// returned, if not, null is returned. Note that this function can fail when 4085520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// attempting to fold instructions like loads and stores, which have no 4095520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// constant expression form. 4105520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// 411f286f6fd93d569befe6e77c94a947e6e04e95685Chris LattnerConstant *llvm::ConstantFoldInstOperands(unsigned Opcode, const Type *DestTy, 412f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner Constant* const* Ops, unsigned NumOps, 413e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context, 4145520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner const TargetData *TD) { 41503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner // Handle easy binops first. 416f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (Instruction::isBinaryOp(Opcode)) { 41703dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner if (isa<ConstantExpr>(Ops[0]) || isa<ConstantExpr>(Ops[1])) 418508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson if (Constant *C = SymbolicallyEvaluateBinop(Opcode, Ops[0], Ops[1], TD, 419508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context)) 42003dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return C; 42103dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 422baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::get(Opcode, Ops[0], Ops[1]); 42303dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner } 4245520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 425f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner switch (Opcode) { 4265520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner default: return 0; 4275520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::Call: 4285520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (Function *F = dyn_cast<Function>(Ops[0])) 4295520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (canConstantFoldCallTo(F)) 430ad58eb34342f70f094008e6d08cb4ed814754e64Chris Lattner return ConstantFoldCall(F, Ops+1, NumOps-1); 4315520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 4325520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::ICmp: 4335520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::FCmp: 434c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("This function is invalid for compares: no predicate specified"); 435001f7534e0311508cc93831a595785bb177f8a18Chris Lattner case Instruction::PtrToInt: 436001f7534e0311508cc93831a595785bb177f8a18Chris Lattner // If the input is a inttoptr, eliminate the pair. This requires knowing 437001f7534e0311508cc93831a595785bb177f8a18Chris Lattner // the width of a pointer, so it can't be done in ConstantExpr::getCast. 438001f7534e0311508cc93831a595785bb177f8a18Chris Lattner if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ops[0])) { 439001f7534e0311508cc93831a595785bb177f8a18Chris Lattner if (TD && CE->getOpcode() == Instruction::IntToPtr) { 440001f7534e0311508cc93831a595785bb177f8a18Chris Lattner Constant *Input = CE->getOperand(0); 4416de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman unsigned InWidth = Input->getType()->getScalarSizeInBits(); 44204aa2c3520c049333ca216fb794d700310c4a33dNick Lewycky if (TD->getPointerSizeInBits() < InWidth) { 44304aa2c3520c049333ca216fb794d700310c4a33dNick Lewycky Constant *Mask = 444eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantInt::get(Context, APInt::getLowBitsSet(InWidth, 44504aa2c3520c049333ca216fb794d700310c4a33dNick Lewycky TD->getPointerSizeInBits())); 446baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Input = ConstantExpr::getAnd(Input, Mask); 44704aa2c3520c049333ca216fb794d700310c4a33dNick Lewycky } 448001f7534e0311508cc93831a595785bb177f8a18Chris Lattner // Do a zext or trunc to get to the dest size. 449baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getIntegerCast(Input, DestTy, false); 450001f7534e0311508cc93831a595785bb177f8a18Chris Lattner } 451001f7534e0311508cc93831a595785bb177f8a18Chris Lattner } 452baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getCast(Opcode, Ops[0], DestTy); 453001f7534e0311508cc93831a595785bb177f8a18Chris Lattner case Instruction::IntToPtr: 45481b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands // If the input is a ptrtoint, turn the pair into a ptr to ptr bitcast if 45581b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands // the int size is >= the ptr size. This requires knowing the width of a 45681b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands // pointer, so it can't be done in ConstantExpr::getCast. 45781b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands if (ConstantExpr *CE = dyn_cast<ConstantExpr>(Ops[0])) { 4589a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (TD && 45981b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands TD->getPointerSizeInBits() <= 4606de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman CE->getType()->getScalarSizeInBits()) { 4619a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (CE->getOpcode() == Instruction::PtrToInt) { 4629a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman Constant *Input = CE->getOperand(0); 463508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Constant *C = FoldBitCast(Input, DestTy, *TD, Context); 464baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return C ? C : ConstantExpr::getBitCast(Input, DestTy); 4659a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman } 4669a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman // If there's a constant offset added to the integer value before 4679a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman // it is casted back to a pointer, see if the expression can be 4689a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman // converted into a GEP. 4699a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (CE->getOpcode() == Instruction::Add) 4709a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (ConstantInt *L = dyn_cast<ConstantInt>(CE->getOperand(0))) 4719a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (ConstantExpr *R = dyn_cast<ConstantExpr>(CE->getOperand(1))) 4729a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (R->getOpcode() == Instruction::PtrToInt) 4739a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (GlobalVariable *GV = 4749a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman dyn_cast<GlobalVariable>(R->getOperand(0))) { 4759a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman const PointerType *GVTy = cast<PointerType>(GV->getType()); 4769a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (const ArrayType *AT = 4779a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman dyn_cast<ArrayType>(GVTy->getElementType())) { 4789a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman const Type *ElTy = AT->getElementType(); 479777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands uint64_t AllocSize = TD->getTypeAllocSize(ElTy); 480777d2306b36816a53bc1ae1244c0dc7d998ae691Duncan Sands APInt PSA(L->getValue().getBitWidth(), AllocSize); 4819a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (ElTy == cast<PointerType>(DestTy)->getElementType() && 4829a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman L->getValue().urem(PSA) == 0) { 4839a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman APInt ElemIdx = L->getValue().udiv(PSA); 4849a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman if (ElemIdx.ult(APInt(ElemIdx.getBitWidth(), 4859a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman AT->getNumElements()))) { 4869a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman Constant *Index[] = { 487a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson Constant::getNullValue(CE->getType()), 488eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantInt::get(Context, ElemIdx) 4899a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman }; 490508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return 491baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson ConstantExpr::getGetElementPtr(GV, &Index[0], 2); 4929a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman } 4939a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman } 4949a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman } 4959a38e3e3991ea443e555d8060f91202a786acdd4Dan Gohman } 49681b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands } 49781b06be055e74a3c23a1c8f17ead97f9f76335eeDuncan Sands } 498baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getCast(Opcode, Ops[0], DestTy); 4995520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::Trunc: 5005520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::ZExt: 5015520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::SExt: 5025520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::FPTrunc: 5035520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::FPExt: 5045520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::UIToFP: 5055520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::SIToFP: 5065520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::FPToUI: 5075520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::FPToSI: 508baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getCast(Opcode, Ops[0], DestTy); 5095520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::BitCast: 5101afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner if (TD) 511508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson if (Constant *C = FoldBitCast(Ops[0], DestTy, *TD, Context)) 5121afab9c1e0ae2d145ce01718aa14065393117e70Chris Lattner return C; 513baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getBitCast(Ops[0], DestTy); 5145520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::Select: 515baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]); 5165520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::ExtractElement: 517baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getExtractElement(Ops[0], Ops[1]); 5185520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::InsertElement: 519baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]); 5205520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::ShuffleVector: 521baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]); 5225520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner case Instruction::GetElementPtr: 523508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson if (Constant *C = SymbolicallyEvaluateGEP(Ops, NumOps, DestTy, Context, TD)) 52403dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner return C; 52503dd25ca964813c8b9fe14479443b9c21fb92c55Chris Lattner 526baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getGetElementPtr(Ops[0], Ops+1, NumOps-1); 5275520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } 5285520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner} 5295520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 530f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner/// ConstantFoldCompareInstOperands - Attempt to constant fold a compare 531f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner/// instruction (icmp/fcmp) with the specified operands. If it fails, it 532f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner/// returns a constant expression of the specified operands. 533f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner/// 534f286f6fd93d569befe6e77c94a947e6e04e95685Chris LattnerConstant *llvm::ConstantFoldCompareInstOperands(unsigned Predicate, 535f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner Constant*const * Ops, 536f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner unsigned NumOps, 537e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context, 538f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner const TargetData *TD) { 539f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // fold: icmp (inttoptr x), null -> icmp x, 0 540f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // fold: icmp (ptrtoint x), 0 -> icmp x, null 5413dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky // fold: icmp (inttoptr x), (inttoptr y) -> icmp trunc/zext x, trunc/zext y 542f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // fold: icmp (ptrtoint x), (ptrtoint y) -> icmp x, y 543f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // 544f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // ConstantExpr::getCompare cannot do this, because it doesn't have TD 545f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // around to know if bit truncation is happening. 546f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (ConstantExpr *CE0 = dyn_cast<ConstantExpr>(Ops[0])) { 547f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (TD && Ops[1]->isNullValue()) { 5481d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson const Type *IntPtrTy = TD->getIntPtrType(Context); 549f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (CE0->getOpcode() == Instruction::IntToPtr) { 550f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // Convert the integer value to the right size to ensure we get the 551f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // proper extension or truncation. 552baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *C = ConstantExpr::getIntegerCast(CE0->getOperand(0), 553f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner IntPtrTy, false); 554a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson Constant *NewOps[] = { C, Constant::getNullValue(C->getType()) }; 555508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldCompareInstOperands(Predicate, NewOps, 2, 556508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 557f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 558f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner 559f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // Only do this transformation if the int is intptrty in size, otherwise 560f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // there is a truncation or extension that we aren't modeling. 561f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner if (CE0->getOpcode() == Instruction::PtrToInt && 562f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner CE0->getType() == IntPtrTy) { 563f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner Constant *C = CE0->getOperand(0); 564a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson Constant *NewOps[] = { C, Constant::getNullValue(C->getType()) }; 565f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner // FIXME! 566508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldCompareInstOperands(Predicate, NewOps, 2, 567508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 568f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 569f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 570f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner 5713dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky if (ConstantExpr *CE1 = dyn_cast<ConstantExpr>(Ops[1])) { 5723dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky if (TD && CE0->getOpcode() == CE1->getOpcode()) { 5731d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson const Type *IntPtrTy = TD->getIntPtrType(Context); 5743dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky 5753dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky if (CE0->getOpcode() == Instruction::IntToPtr) { 5763dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky // Convert the integer value to the right size to ensure we get the 5773dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky // proper extension or truncation. 578baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *C0 = ConstantExpr::getIntegerCast(CE0->getOperand(0), 5793dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky IntPtrTy, false); 580baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *C1 = ConstantExpr::getIntegerCast(CE1->getOperand(0), 5813dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky IntPtrTy, false); 5823dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky Constant *NewOps[] = { C0, C1 }; 583508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldCompareInstOperands(Predicate, NewOps, 2, 584508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 5853dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky } 5863dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky 5873dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky // Only do this transformation if the int is intptrty in size, otherwise 5883dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky // there is a truncation or extension that we aren't modeling. 5893dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky if ((CE0->getOpcode() == Instruction::PtrToInt && 5903dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky CE0->getType() == IntPtrTy && 5913dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky CE0->getOperand(0)->getType() == CE1->getOperand(0)->getType())) { 5923dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky Constant *NewOps[] = { 5933dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky CE0->getOperand(0), CE1->getOperand(0) 5943dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky }; 595508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldCompareInstOperands(Predicate, NewOps, 2, 596508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson Context, TD); 5973dfd7bf5110c47e99fd0fcce96122b90f699ca3aNick Lewycky } 598f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 599f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 600f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner } 601baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return ConstantExpr::getCompare(Predicate, Ops[0], Ops[1]); 602f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner} 603f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner 604f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattner 6055520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// ConstantFoldLoadThroughGEPConstantExpr - Given a constant and a 6065520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// getelementptr constantexpr, return the constant value being addressed by the 6075520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner/// constant expression, or null if something is funny and we can't decide. 6085520732b24a5a321140dd79af70d321c7ff3dec9Chris LattnerConstant *llvm::ConstantFoldLoadThroughGEPConstantExpr(Constant *C, 609508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson ConstantExpr *CE, 610e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context) { 611a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson if (CE->getOperand(1) != Constant::getNullValue(CE->getOperand(1)->getType())) 6125520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; // Do not allow stepping over the value! 6135520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 6145520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // Loop over all of the operands, tracking down which value we are 6155520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner // addressing... 6165520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner gep_type_iterator I = gep_type_begin(CE), E = gep_type_end(CE); 6175520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner for (++I; I != E; ++I) 6185520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (const StructType *STy = dyn_cast<StructType>(*I)) { 6195520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner ConstantInt *CU = cast<ConstantInt>(I.getOperand()); 6205520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner assert(CU->getZExtValue() < STy->getNumElements() && 6215520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner "Struct index out of range!"); 6225520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner unsigned El = (unsigned)CU->getZExtValue(); 6235520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (ConstantStruct *CS = dyn_cast<ConstantStruct>(C)) { 6245520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner C = CS->getOperand(El); 6255520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else if (isa<ConstantAggregateZero>(C)) { 626a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson C = Constant::getNullValue(STy->getElementType(El)); 6275520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else if (isa<UndefValue>(C)) { 6289e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson C = UndefValue::get(STy->getElementType(El)); 6295520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else { 6305520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6315520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } 6325520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else if (ConstantInt *CI = dyn_cast<ConstantInt>(I.getOperand())) { 6335520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (const ArrayType *ATy = dyn_cast<ArrayType>(*I)) { 6345520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (CI->getZExtValue() >= ATy->getNumElements()) 6355520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6365520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (ConstantArray *CA = dyn_cast<ConstantArray>(C)) 6375520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner C = CA->getOperand(CI->getZExtValue()); 6385520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else if (isa<ConstantAggregateZero>(C)) 639a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson C = Constant::getNullValue(ATy->getElementType()); 6405520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else if (isa<UndefValue>(C)) 6419e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson C = UndefValue::get(ATy->getElementType()); 6425520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else 6435520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6449d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer } else if (const VectorType *PTy = dyn_cast<VectorType>(*I)) { 6455520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner if (CI->getZExtValue() >= PTy->getNumElements()) 6465520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6479d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencer if (ConstantVector *CP = dyn_cast<ConstantVector>(C)) 6485520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner C = CP->getOperand(CI->getZExtValue()); 6495520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else if (isa<ConstantAggregateZero>(C)) 650a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson C = Constant::getNullValue(PTy->getElementType()); 6515520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else if (isa<UndefValue>(C)) 6529e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson C = UndefValue::get(PTy->getElementType()); 6535520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner else 6545520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6555520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else { 6565520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6575520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } 6585520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } else { 6595520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return 0; 6605520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner } 6615520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner return C; 6625520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner} 6635520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 6645520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner 665bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell//===----------------------------------------------------------------------===// 6665520732b24a5a321140dd79af70d321c7ff3dec9Chris Lattner// Constant Folding for Calls 667bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell// 668bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 669bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell/// canConstantFoldCallTo - Return true if its even possible to fold a call to 670bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell/// the specified function. 671bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswellbool 672fa9b80eb64127b3d9691e18537975635520e51e9Dan Gohmanllvm::canConstantFoldCallTo(const Function *F) { 673bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell switch (F->getIntrinsicID()) { 6749ab7fb3ba47442d521a5bed09a27a5e8e7a786edDale Johannesen case Intrinsic::sqrt: 6759ab7fb3ba47442d521a5bed09a27a5e8e7a786edDale Johannesen case Intrinsic::powi: 676e9391fd9b52e93717b365bdd05c471101323a4dfReid Spencer case Intrinsic::bswap: 677e9391fd9b52e93717b365bdd05c471101323a4dfReid Spencer case Intrinsic::ctpop: 678e9391fd9b52e93717b365bdd05c471101323a4dfReid Spencer case Intrinsic::ctlz: 679e9391fd9b52e93717b365bdd05c471101323a4dfReid Spencer case Intrinsic::cttz: 680bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell return true; 68168a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner default: 68268a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner return false; 68368a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner case 0: break; 684bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 685bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 6866f532a988e5c02fcb271fb65e9e7b83f0147d3f2Chris Lattner if (!F->hasName()) return false; 687f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar StringRef Name = F->getName(); 688c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner 689c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner // In these cases, the check of the length is required. We don't want to 690c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner // return true for a name like "cos\0blah" which strcmp would return equal to 691c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner // "cos", but has length 8. 692f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar switch (Name[0]) { 693c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner default: return false; 694c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'a': 695f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "acos" || Name == "asin" || 696f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar Name == "atan" || Name == "atan2"; 697c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'c': 698f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "cos" || Name == "ceil" || Name == "cosf" || Name == "cosh"; 699c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'e': 700f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "exp"; 701c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'f': 702f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "fabs" || Name == "fmod" || Name == "floor"; 703c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'l': 704f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "log" || Name == "log10"; 705c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'p': 706f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "pow"; 707c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 's': 708f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "sin" || Name == "sinh" || Name == "sqrt" || 709f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar Name == "sinf" || Name == "sqrtf"; 710c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 't': 711f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar return Name == "tan" || Name == "tanh"; 712bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 713bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell} 714bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 71572d88ae5447a3929c97e88f4c806213847b5d988Chris Lattnerstatic Constant *ConstantFoldFP(double (*NativeFP)(double), double V, 716e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson const Type *Ty, LLVMContext &Context) { 717bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell errno = 0; 718bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell V = NativeFP(V); 719f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner if (errno != 0) { 720f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner errno = 0; 721f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner return 0; 72243421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen } 723f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner 724d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner if (Ty->isFloatTy()) 7256f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat((float)V)); 726d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner if (Ty->isDoubleTy()) 7276f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat(V)); 728c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Can only constant fold float/double"); 72933e456d5f3909e0c7b96e04e5674c25a182da100Gabor Greif return 0; // dummy return to suppress warning 730bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell} 731bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 732384152444d22d356f7b4090a158da4cbc1f79464Dan Gohmanstatic Constant *ConstantFoldBinaryFP(double (*NativeFP)(double, double), 733384152444d22d356f7b4090a158da4cbc1f79464Dan Gohman double V, double W, 734508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson const Type *Ty, 735e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context) { 736384152444d22d356f7b4090a158da4cbc1f79464Dan Gohman errno = 0; 737384152444d22d356f7b4090a158da4cbc1f79464Dan Gohman V = NativeFP(V, W); 738f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner if (errno != 0) { 739f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner errno = 0; 740f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner return 0; 74143421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen } 742f19f58a9360927f8ef50b9a029e8efb780d3d8a8Chris Lattner 743d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner if (Ty->isFloatTy()) 7446f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat((float)V)); 745d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner if (Ty->isDoubleTy()) 7466f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat(V)); 747c23197a26f34f559ea9797de51e187087c039c42Torok Edwin llvm_unreachable("Can only constant fold float/double"); 74833e456d5f3909e0c7b96e04e5674c25a182da100Gabor Greif return 0; // dummy return to suppress warning 749384152444d22d356f7b4090a158da4cbc1f79464Dan Gohman} 750384152444d22d356f7b4090a158da4cbc1f79464Dan Gohman 751bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell/// ConstantFoldCall - Attempt to constant fold a call to the specified function 752bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell/// with the specified arguments, returning null if unsuccessful. 753bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John CriswellConstant * 754f286f6fd93d569befe6e77c94a947e6e04e95685Chris Lattnerllvm::ConstantFoldCall(Function *F, 75568a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner Constant *const *Operands, unsigned NumOperands) { 7566f532a988e5c02fcb271fb65e9e7b83f0147d3f2Chris Lattner if (!F->hasName()) return 0; 757e922c0201916e0b980ab3cfe91e1413e68d55647Owen Anderson LLVMContext &Context = F->getContext(); 758f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar StringRef Name = F->getName(); 759d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner 760bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell const Type *Ty = F->getReturnType(); 76172d88ae5447a3929c97e88f4c806213847b5d988Chris Lattner if (NumOperands == 1) { 762bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell if (ConstantFP *Op = dyn_cast<ConstantFP>(Operands[0])) { 763d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner if (!Ty->isFloatTy() && !Ty->isDoubleTy()) 76443421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen return 0; 76543421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen /// Currently APFloat versions of these functions do not exist, so we use 76643421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen /// the host native double versions. Float versions are not called 76743421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen /// directly but for all these it is true (float)(f((double)arg)) == 76843421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen /// f(arg). Long double not supported yet. 769d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner double V = Ty->isFloatTy() ? (double)Op->getValueAPF().convertToFloat() : 77043421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen Op->getValueAPF().convertToDouble(); 771f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar switch (Name[0]) { 772c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'a': 773f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "acos") 774508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(acos, V, Ty, Context); 775f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "asin") 776508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(asin, V, Ty, Context); 777f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "atan") 778508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(atan, V, Ty, Context); 779c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 780c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'c': 781f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "ceil") 782508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(ceil, V, Ty, Context); 783f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "cos") 784508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(cos, V, Ty, Context); 785f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "cosh") 786508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(cosh, V, Ty, Context); 787f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "cosf") 788508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(cos, V, Ty, Context); 789c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 790c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'e': 791f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "exp") 792508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(exp, V, Ty, Context); 793c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 794c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'f': 795f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "fabs") 796508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(fabs, V, Ty, Context); 797f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "floor") 798508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(floor, V, Ty, Context); 799c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 800c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 'l': 801f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "log" && V > 0) 802508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(log, V, Ty, Context); 803f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "log10" && V > 0) 804508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(log10, V, Ty, Context); 805f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "llvm.sqrt.f32" || 806f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar Name == "llvm.sqrt.f64") { 807c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner if (V >= -0.0) 808508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sqrt, V, Ty, Context); 809c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner else // Undefined 810a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return Constant::getNullValue(Ty); 811c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner } 812c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 813c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 's': 814f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "sin") 815508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sin, V, Ty, Context); 816f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "sinh") 817508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sinh, V, Ty, Context); 818f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "sqrt" && V >= 0) 819508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sqrt, V, Ty, Context); 820f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "sqrtf" && V >= 0) 821508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sqrt, V, Ty, Context); 822f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "sinf") 823508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(sin, V, Ty, Context); 824c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 825c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner case 't': 826f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name == "tan") 827508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(tan, V, Ty, Context); 828f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name == "tanh") 829508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldFP(tanh, V, Ty, Context); 830c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 831c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner default: 832c5f6a1f9d61d74017d90e149728cb3d283e0a0e0Chris Lattner break; 833bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 83468a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner return 0; 83568a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner } 83668a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner 83768a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner 83868a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner if (ConstantInt *Op = dyn_cast<ConstantInt>(Operands[0])) { 839f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar if (Name.startswith("llvm.bswap")) 840eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return ConstantInt::get(Context, Op->getValue().byteSwap()); 841f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name.startswith("llvm.ctpop")) 842eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return ConstantInt::get(Ty, Op->getValue().countPopulation()); 843f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name.startswith("llvm.cttz")) 844eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return ConstantInt::get(Ty, Op->getValue().countTrailingZeros()); 845f0443c1eb44d737d9bd78962932fc80f74c6113cDaniel Dunbar else if (Name.startswith("llvm.ctlz")) 846eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return ConstantInt::get(Ty, Op->getValue().countLeadingZeros()); 84768a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner return 0; 848bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 84968a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner 85068a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner return 0; 85168a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner } 85268a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner 85368a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner if (NumOperands == 2) { 854bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell if (ConstantFP *Op1 = dyn_cast<ConstantFP>(Operands[0])) { 855d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner if (!Ty->isFloatTy() && !Ty->isDoubleTy()) 8569ab7fb3ba47442d521a5bed09a27a5e8e7a786edDale Johannesen return 0; 857d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner double Op1V = Ty->isFloatTy() ? 858d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner (double)Op1->getValueAPF().convertToFloat() : 85943421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen Op1->getValueAPF().convertToDouble(); 860bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell if (ConstantFP *Op2 = dyn_cast<ConstantFP>(Operands[1])) { 861d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner if (Op2->getType() != Op1->getType()) 862d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner return 0; 863d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner 864d0806a1519f3bc450d2dea3e6f22db73fc797e4cChris Lattner double Op2V = Ty->isFloatTy() ? 86543421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen (double)Op2->getValueAPF().convertToFloat(): 86643421b3dd70af5b70e71816521f37502c397cc65Dale Johannesen Op2->getValueAPF().convertToDouble(); 867bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 86868a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner if (Name == "pow") 869508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldBinaryFP(pow, Op1V, Op2V, Ty, Context); 87068a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner if (Name == "fmod") 871508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldBinaryFP(fmod, Op1V, Op2V, Ty, Context); 87268a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner if (Name == "atan2") 873508955156a25a9abc470a29e1760aa176d341cf9Owen Anderson return ConstantFoldBinaryFP(atan2, Op1V, Op2V, Ty, Context); 874b5282dcf4745be59046f440980a1c0f0a50c9c09Chris Lattner } else if (ConstantInt *Op2C = dyn_cast<ConstantInt>(Operands[1])) { 87568a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner if (Name == "llvm.powi.f32") 8766f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat((float)std::pow((float)Op1V, 87702a260aa11a2e1b2c14335274d3c42ca3f3eabc0Chris Lattner (int)Op2C->getZExtValue()))); 87868a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner if (Name == "llvm.powi.f64") 8796f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return ConstantFP::get(Context, APFloat((double)std::pow((double)Op1V, 88002a260aa11a2e1b2c14335274d3c42ca3f3eabc0Chris Lattner (int)Op2C->getZExtValue()))); 881bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 88268a0603dc5d3d79cd4de2195e950af26c3380cd7Chris Lattner return 0; 883bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 884bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell } 885bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell return 0; 886bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell} 887bd9d37026a5c17d9a51371a6a5446bf4761ee7d6John Criswell 888