19bc02a4debba3b279350235a198f651be5d2722eChris Lattner//===-- Constants.cpp - Implement Constant nodes --------------------------===// 2fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 3b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// The LLVM Compiler Infrastructure 4b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell// 54ee451de366474b9c228b4e5fa573795a715216dChris Lattner// This file is distributed under the University of Illinois Open Source 64ee451de366474b9c228b4e5fa573795a715216dChris Lattner// License. See LICENSE.TXT for details. 7fd93908ae8b9684fe71c239e3c6cfe13ff6a2663Misha Brukman// 8b576c94c15af9a440f69d9d03c2afead7971118cJohn Criswell//===----------------------------------------------------------------------===// 9009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 10eb59ca976c6400936ee28b7c8687bda9c4ea1cdfChris Lattner// This file implements the Constant* classes. 11009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// 12009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 13009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 140b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Constants.h" 1592f6feaf792469130eec7196854ff01215955964Chris Lattner#include "ConstantFold.h" 16d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "LLVMContextImpl.h" 17d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/DenseMap.h" 18d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/FoldingSet.h" 19d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/STLExtras.h" 20d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/SmallVector.h" 21d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/StringExtras.h" 22d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/ADT/StringMap.h" 230b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/DerivedTypes.h" 240b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/GlobalValue.h" 250b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 260b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Module.h" 270b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 28a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 292e3def1177c462e14b20ddad71adf5c6b7c3e867Bill Wendling#include "llvm/Support/Debug.h" 307d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.h" 31d04a8d4b33ff316ca4cf961e06c9e312eff8e64fChandler Carruth#include "llvm/Support/GetElementPtrTypeIterator.h" 328a94bf142ac7ab47fdeef44bbb6cceecf234b43eChris Lattner#include "llvm/Support/ManagedStatic.h" 332e3def1177c462e14b20ddad71adf5c6b7c3e867Bill Wendling#include "llvm/Support/MathExtras.h" 3437f077a8dad6a6a307204ec98f6d155c1576d6d2Chris Lattner#include "llvm/Support/raw_ostream.h" 35009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner#include <algorithm> 3641ee4e57ea0f2afb89fd136065edb03f32f972d3Talin#include <cstdarg> 3731f8499e83dc4dccbb57ea7e76d1fd49b7010d0cChris Lattnerusing namespace llvm; 38d0fde30ce850b78371fd1386338350591f9ff494Brian Gaeke 39009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 40e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner// Constant Class 41009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 42009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 432d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid Constant::anchor() { } 442d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 45b447387726ff94ddb2a23408f39e22714c42f79bChris Lattnerbool Constant::isNegativeZeroValue() const { 46b447387726ff94ddb2a23408f39e22714c42f79bChris Lattner // Floating point values have an explicit -0.0 value. 47b447387726ff94ddb2a23408f39e22714c42f79bChris Lattner if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this)) 48b447387726ff94ddb2a23408f39e22714c42f79bChris Lattner return CFP->isZero() && CFP->isNegative(); 49a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 50ec7eb55cc4c35318ff0ec4e04c0d42e5a65e1811David Tweed // Equivalent for a vector of -0.0's. 51ec7eb55cc4c35318ff0ec4e04c0d42e5a65e1811David Tweed if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) 52ec7eb55cc4c35318ff0ec4e04c0d42e5a65e1811David Tweed if (ConstantFP *SplatCFP = dyn_cast_or_null<ConstantFP>(CV->getSplatValue())) 53ec7eb55cc4c35318ff0ec4e04c0d42e5a65e1811David Tweed if (SplatCFP && SplatCFP->isZero() && SplatCFP->isNegative()) 54ec7eb55cc4c35318ff0ec4e04c0d42e5a65e1811David Tweed return true; 55ec7eb55cc4c35318ff0ec4e04c0d42e5a65e1811David Tweed 56974cdfb17a08abae3ba5850bc1a1c801f41319c1David Tweed // We've already handled true FP case; any other FP vectors can't represent -0.0. 57974cdfb17a08abae3ba5850bc1a1c801f41319c1David Tweed if (getType()->isFPOrFPVectorTy()) 58974cdfb17a08abae3ba5850bc1a1c801f41319c1David Tweed return false; 59ec7eb55cc4c35318ff0ec4e04c0d42e5a65e1811David Tweed 60b447387726ff94ddb2a23408f39e22714c42f79bChris Lattner // Otherwise, just use +0.0. 61b447387726ff94ddb2a23408f39e22714c42f79bChris Lattner return isNullValue(); 62b447387726ff94ddb2a23408f39e22714c42f79bChris Lattner} 63b447387726ff94ddb2a23408f39e22714c42f79bChris Lattner 64c3d6de2fe52dbdbf41b1dfebb1430656a16b254bShuxin Yang// Return true iff this constant is positive zero (floating point), negative 65c3d6de2fe52dbdbf41b1dfebb1430656a16b254bShuxin Yang// zero (floating point), or a null value. 66935e35d2b9f889566207b76a7026b63a1619742cShuxin Yangbool Constant::isZeroValue() const { 67935e35d2b9f889566207b76a7026b63a1619742cShuxin Yang // Floating point values have an explicit -0.0 value. 68935e35d2b9f889566207b76a7026b63a1619742cShuxin Yang if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this)) 69935e35d2b9f889566207b76a7026b63a1619742cShuxin Yang return CFP->isZero(); 70935e35d2b9f889566207b76a7026b63a1619742cShuxin Yang 71935e35d2b9f889566207b76a7026b63a1619742cShuxin Yang // Otherwise, just use +0.0. 72935e35d2b9f889566207b76a7026b63a1619742cShuxin Yang return isNullValue(); 73935e35d2b9f889566207b76a7026b63a1619742cShuxin Yang} 74935e35d2b9f889566207b76a7026b63a1619742cShuxin Yang 75032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattnerbool Constant::isNullValue() const { 76032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattner // 0 is null. 77032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattner if (const ConstantInt *CI = dyn_cast<ConstantInt>(this)) 78032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattner return CI->isZero(); 79a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 80032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattner // +0.0 is null. 81032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattner if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this)) 82032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattner return CFP->isZero() && !CFP->isNegative(); 83032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattner 84032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattner // constant zero is zero for aggregates and cpnull is null for pointers. 85032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattner return isa<ConstantAggregateZero>(this) || isa<ConstantPointerNull>(this); 86032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattner} 87032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattner 884c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotembool Constant::isAllOnesValue() const { 894c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem // Check for -1 integers 904c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem if (const ConstantInt *CI = dyn_cast<ConstantInt>(this)) 914c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem return CI->isMinusOne(); 924c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem 934c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem // Check for FP which are bitcasted from -1 integers 944c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this)) 954c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem return CFP->getValueAPF().bitcastToAPInt().isAllOnesValue(); 964c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem 97b518cae015f9a91aa5035e4047e50215a47a7bb2Benjamin Kramer // Check for constant vectors which are splats of -1 values. 984c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) 99b518cae015f9a91aa5035e4047e50215a47a7bb2Benjamin Kramer if (Constant *Splat = CV->getSplatValue()) 100b518cae015f9a91aa5035e4047e50215a47a7bb2Benjamin Kramer return Splat->isAllOnesValue(); 1014c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem 102e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner // Check for constant vectors which are splats of -1 values. 103e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) 104e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (Constant *Splat = CV->getSplatValue()) 105e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner return Splat->isAllOnesValue(); 106e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner 1074c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem return false; 1084c7c0f23533565c7e2ddf71e01bf50f2aede5f1bNadav Rotem} 109b518cae015f9a91aa5035e4047e50215a47a7bb2Benjamin Kramer 110a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson// Constructor to create a '0' constant of arbitrary type... 111db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *Constant::getNullValue(Type *Ty) { 112a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson switch (Ty->getTypeID()) { 113a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::IntegerTyID: 114a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return ConstantInt::get(Ty, 0); 115ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman case Type::HalfTyID: 116ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return ConstantFP::get(Ty->getContext(), 117ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman APFloat::getZero(APFloat::IEEEhalf)); 118a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::FloatTyID: 119983839609ffa589cda60efaea847eecede77b524Benjamin Kramer return ConstantFP::get(Ty->getContext(), 120983839609ffa589cda60efaea847eecede77b524Benjamin Kramer APFloat::getZero(APFloat::IEEEsingle)); 121a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::DoubleTyID: 122983839609ffa589cda60efaea847eecede77b524Benjamin Kramer return ConstantFP::get(Ty->getContext(), 123983839609ffa589cda60efaea847eecede77b524Benjamin Kramer APFloat::getZero(APFloat::IEEEdouble)); 124a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::X86_FP80TyID: 125983839609ffa589cda60efaea847eecede77b524Benjamin Kramer return ConstantFP::get(Ty->getContext(), 126983839609ffa589cda60efaea847eecede77b524Benjamin Kramer APFloat::getZero(APFloat::x87DoubleExtended)); 127a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::FP128TyID: 128a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return ConstantFP::get(Ty->getContext(), 129983839609ffa589cda60efaea847eecede77b524Benjamin Kramer APFloat::getZero(APFloat::IEEEquad)); 130a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::PPC_FP128TyID: 131983839609ffa589cda60efaea847eecede77b524Benjamin Kramer return ConstantFP::get(Ty->getContext(), 1320a29cb045444c13160e90fe7942a9d7c720185edTim Northover APFloat(APFloat::PPCDoubleDouble, 1330a29cb045444c13160e90fe7942a9d7c720185edTim Northover APInt::getNullValue(128))); 134a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::PointerTyID: 135a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return ConstantPointerNull::get(cast<PointerType>(Ty)); 136a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::StructTyID: 137a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::ArrayTyID: 138a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::VectorTyID: 139a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return ConstantAggregateZero::get(Ty); 140a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson default: 141a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson // Function, Label, or Opaque type? 14250bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("Cannot create a null constant of that type!"); 143a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson } 144a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson} 145a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson 146db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *Constant::getIntegerValue(Type *Ty, const APInt &V) { 147db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ScalarTy = Ty->getScalarType(); 14843ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman 14943ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman // Create the base integer constant. 15043ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman Constant *C = ConstantInt::get(Ty->getContext(), V); 15143ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman 15243ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman // Convert an integer to a pointer, if necessary. 153db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (PointerType *PTy = dyn_cast<PointerType>(ScalarTy)) 15443ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman C = ConstantExpr::getIntToPtr(C, PTy); 15543ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman 15643ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman // Broadcast a scalar to a vector, if necessary. 157db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 1583c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner C = ConstantVector::getSplat(VTy->getNumElements(), C); 15943ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman 16043ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman return C; 16143ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman} 16243ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman 163db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *Constant::getAllOnesValue(Type *Ty) { 164db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (IntegerType *ITy = dyn_cast<IntegerType>(Ty)) 165a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return ConstantInt::get(Ty->getContext(), 166a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson APInt::getAllOnesValue(ITy->getBitWidth())); 167093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem 168093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem if (Ty->isFloatingPointTy()) { 169093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem APFloat FL = APFloat::getAllOnesValue(Ty->getPrimitiveSizeInBits(), 170093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem !Ty->isPPC_FP128Ty()); 171093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem return ConstantFP::get(Ty->getContext(), FL); 172093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem } 173093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem 174db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *VTy = cast<VectorType>(Ty); 1753c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), 1763c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner getAllOnesValue(VTy->getElementType())); 177a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson} 178a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson 1793d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner/// getAggregateElement - For aggregates (struct/array/vector) return the 1803d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner/// constant that corresponds to the specified element if possible, or null if 1813d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner/// not. This can return null if the element index is a ConstantExpr, or if 1823d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner/// 'this' is a constant expr. 1833d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *Constant::getAggregateElement(unsigned Elt) const { 1843d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(this)) 1853d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner return Elt < CS->getNumOperands() ? CS->getOperand(Elt) : 0; 186a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1873d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (const ConstantArray *CA = dyn_cast<ConstantArray>(this)) 1883d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner return Elt < CA->getNumOperands() ? CA->getOperand(Elt) : 0; 189a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1903d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) 1913d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner return Elt < CV->getNumOperands() ? CV->getOperand(Elt) : 0; 192a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1933d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (const ConstantAggregateZero *CAZ =dyn_cast<ConstantAggregateZero>(this)) 1943d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner return CAZ->getElementValue(Elt); 195a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1963d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (const UndefValue *UV = dyn_cast<UndefValue>(this)) 1973d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner return UV->getElementValue(Elt); 198a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 199230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (const ConstantDataSequential *CDS =dyn_cast<ConstantDataSequential>(this)) 20018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return Elt < CDS->getNumElements() ? CDS->getElementAsConstant(Elt) : 0; 2013d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner return 0; 2023d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner} 2033d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner 2043d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *Constant::getAggregateElement(Constant *Elt) const { 2053d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner assert(isa<IntegerType>(Elt->getType()) && "Index must be an integer"); 2063d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Elt)) 2073d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner return getAggregateElement(CI->getZExtValue()); 2083d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner return 0; 2093d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner} 2103d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner 2113d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner 2129fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattnervoid Constant::destroyConstantImpl() { 2139fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // When a Constant is destroyed, there may be lingering 2149fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // references to the constant by other constants in the constant pool. These 215ef6a6a69ff1e1b709d0acb315b9f6c926c67a778Misha Brukman // constants are implicitly dependent on the module that is being deleted, 2169fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // but they don't know that. Because we only find out when the CPV is 2179fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // deleted, we must now notify all of our users (that should only be 2189fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // Constants) that they are, in fact, invalid now and should be deleted. 2199fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // 2209fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner while (!use_empty()) { 2219fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner Value *V = use_back(); 2229fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner#ifndef NDEBUG // Only in -g mode... 22337f077a8dad6a6a307204ec98f6d155c1576d6d2Chris Lattner if (!isa<Constant>(V)) { 224d2e63b7fdbdfd0f6986cc1563a6f0cc9446926c9David Greene dbgs() << "While deleting: " << *this 22537f077a8dad6a6a307204ec98f6d155c1576d6d2Chris Lattner << "\n\nUse still stuck around after Def is destroyed: " 22637f077a8dad6a6a307204ec98f6d155c1576d6d2Chris Lattner << *V << "\n\n"; 22737f077a8dad6a6a307204ec98f6d155c1576d6d2Chris Lattner } 2289fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner#endif 2299fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner assert(isa<Constant>(V) && "References remain to Constant being destroyed"); 230230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner cast<Constant>(V)->destroyConstant(); 2319fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner 2329fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // The constant should remove itself from our use list... 2339fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner assert((use_empty() || use_back() != V) && "Constant not removed!"); 2349fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner } 2359fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner 2369fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // Value has no outstanding references it is safe to delete it now... 2379fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner delete this; 2389fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner} 2399fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner 2408848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramerstatic bool canTrapImpl(const Constant *C, 2418848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer SmallPtrSet<const ConstantExpr *, 4> &NonTrappingOps) { 2428848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer assert(C->getType()->isFirstClassType() && "Cannot evaluate aggregate vals!"); 24335b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner // The only thing that could possibly trap are constant exprs. 2448848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer const ConstantExpr *CE = dyn_cast<ConstantExpr>(C); 2458848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer if (!CE) 2468848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer return false; 247a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 248a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova // ConstantExpr traps if any operands can trap. 2498848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { 2508848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer if (ConstantExpr *Op = dyn_cast<ConstantExpr>(CE->getOperand(i))) { 2518848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer if (NonTrappingOps.insert(Op) && canTrapImpl(Op, NonTrappingOps)) 2528848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer return true; 2538848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer } 2548848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer } 25535b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner 25635b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner // Otherwise, only specific operations can trap. 25735b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner switch (CE->getOpcode()) { 25835b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner default: 25935b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner return false; 2601628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::UDiv: 2611628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::SDiv: 2621628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::FDiv: 2630a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::URem: 2640a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::SRem: 2650a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::FRem: 26635b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner // Div and rem can trap if the RHS is not known to be non-zero. 2670eeb913aa17a68b1f2963b02ca1d68f09dba0b78Chris Lattner if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue()) 26835b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner return true; 26935b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner return false; 27035b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner } 27135b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner} 27235b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner 2738848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer/// canTrap - Return true if evaluation of this constant could trap. This is 2748848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer/// true for things like constant expressions that could divide by zero. 2758848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramerbool Constant::canTrap() const { 2768848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer SmallPtrSet<const ConstantExpr *, 4> NonTrappingOps; 2778848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer return canTrapImpl(this, NonTrappingOps); 2788848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer} 2798848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer 2801839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg/// isThreadDependent - Return true if the value can vary between threads. 2811839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborgbool Constant::isThreadDependent() const { 2821839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg SmallPtrSet<const Constant*, 64> Visited; 2831839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg SmallVector<const Constant*, 64> WorkList; 2841839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg WorkList.push_back(this); 2851839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg Visited.insert(this); 2861839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg 2871839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg while (!WorkList.empty()) { 2881839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg const Constant *C = WorkList.pop_back_val(); 2891839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg 2901839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg if (const GlobalVariable *GV = dyn_cast<GlobalVariable>(C)) { 2911839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg if (GV->isThreadLocal()) 2921839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg return true; 2931839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg } 2941839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg 2951839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg for (unsigned I = 0, E = C->getNumOperands(); I != E; ++I) { 296fbeb956876573ae9ec6ddd190eb37e9174489c79Hans Wennborg const Constant *D = dyn_cast<Constant>(C->getOperand(I)); 297fbeb956876573ae9ec6ddd190eb37e9174489c79Hans Wennborg if (!D) 298fbeb956876573ae9ec6ddd190eb37e9174489c79Hans Wennborg continue; 2991839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg if (Visited.insert(D)) 3001839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg WorkList.push_back(D); 3011839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg } 3021839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg } 3031839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg 3041839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg return false; 3051839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg} 3061839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg 3074a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner/// isConstantUsed - Return true if the constant has users other than constant 3084a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner/// exprs and other dangling things. 3094a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattnerbool Constant::isConstantUsed() const { 31060ad781c61815ca5b8dc2a45a102e1c8af65992fGabor Greif for (const_use_iterator UI = use_begin(), E = use_end(); UI != E; ++UI) { 3114a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner const Constant *UC = dyn_cast<Constant>(*UI); 3124a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner if (UC == 0 || isa<GlobalValue>(UC)) 3134a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner return true; 314a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 3154a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner if (UC->isConstantUsed()) 3164a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner return true; 3174a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner } 3184a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner return false; 3194a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner} 3204a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner 3214a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner 32248738b9244217f9e6638513598f875ff59fbc5e6Anton Korobeynikov 3237cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// getRelocationInfo - This method classifies the entry according to 3247cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// whether or not it may generate a relocation entry. This must be 3257cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// conservative, so if it might codegen to a relocatable entry, it should say 3267cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// so. The return values are: 3277cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// 328083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// NoRelocation: This constant pool entry is guaranteed to never have a 329083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// relocation applied to it (because it holds a simple constant like 330083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// '4'). 331083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// LocalRelocation: This entry has relocations, but the entries are 332083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// guaranteed to be resolvable by the static linker, so the dynamic 333083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// linker will never see them. 334083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// GlobalRelocations: This entry may have arbitrary relocations. 3357cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// 336c2c50cdcdc19a1bca993c06d13d8cdca87083ce4Chandler Carruth/// FIXME: This really should not be in IR. 337083a1e059768f6844b9f5292223bb49ad24f52d1Chris LattnerConstant::PossibleRelocationsTy Constant::getRelocationInfo() const { 338083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) { 3397cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner if (GV->hasLocalLinkage() || GV->hasHiddenVisibility()) 340083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner return LocalRelocation; // Local to this file/library. 341083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner return GlobalRelocations; // Global reference. 342ab267a28239f628e65bef34578695d80ba6d0a9eAnton Korobeynikov } 3437cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner 3445d81befc217bdd89ec17979797cfa297985e79d7Chris Lattner if (const BlockAddress *BA = dyn_cast<BlockAddress>(this)) 3455d81befc217bdd89ec17979797cfa297985e79d7Chris Lattner return BA->getFunction()->getRelocationInfo(); 3465d81befc217bdd89ec17979797cfa297985e79d7Chris Lattner 3475099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner // While raw uses of blockaddress need to be relocated, differences between 3485099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner // two of them don't when they are for labels in the same function. This is a 3495099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner // common idiom when creating a table for the indirect goto extension, so we 3505099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner // handle it efficiently here. 3515099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) 3525099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner if (CE->getOpcode() == Instruction::Sub) { 3535099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner ConstantExpr *LHS = dyn_cast<ConstantExpr>(CE->getOperand(0)); 3545099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner ConstantExpr *RHS = dyn_cast<ConstantExpr>(CE->getOperand(1)); 3555099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner if (LHS && RHS && 3565099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner LHS->getOpcode() == Instruction::PtrToInt && 3575099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner RHS->getOpcode() == Instruction::PtrToInt && 3585099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner isa<BlockAddress>(LHS->getOperand(0)) && 3595099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner isa<BlockAddress>(RHS->getOperand(0)) && 3605099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner cast<BlockAddress>(LHS->getOperand(0))->getFunction() == 3615099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner cast<BlockAddress>(RHS->getOperand(0))->getFunction()) 3625099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner return NoRelocation; 3635099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner } 364a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 365083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner PossibleRelocationsTy Result = NoRelocation; 366afe15815571b34d7d53e5a005240686089b18361Evan Cheng for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 3670eeb913aa17a68b1f2963b02ca1d68f09dba0b78Chris Lattner Result = std::max(Result, 3680eeb913aa17a68b1f2963b02ca1d68f09dba0b78Chris Lattner cast<Constant>(getOperand(i))->getRelocationInfo()); 369a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 3707cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner return Result; 371afe15815571b34d7d53e5a005240686089b18361Evan Cheng} 372afe15815571b34d7d53e5a005240686089b18361Evan Cheng 37313fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// removeDeadUsersOfConstant - If the specified constantexpr is dead, remove 37413fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// it. This involves recursively eliminating any dead users of the 37513fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// constantexpr. 37613fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattnerstatic bool removeDeadUsersOfConstant(const Constant *C) { 37713fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (isa<GlobalValue>(C)) return false; // Cannot remove this 378a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 37913fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner while (!C->use_empty()) { 38013fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner const Constant *User = dyn_cast<Constant>(C->use_back()); 38113fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (!User) return false; // Non-constant usage; 38213fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (!removeDeadUsersOfConstant(User)) 38313fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner return false; // Constant wasn't dead 38413fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } 385a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 38613fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner const_cast<Constant*>(C)->destroyConstant(); 38713fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner return true; 38813fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner} 38913fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner 39013fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner 39113fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// removeDeadConstantUsers - If there are any dead constant users dangling 39213fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// off of this constant, remove them. This method is useful for clients 39313fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// that want to check to see if a global is unused, but don't want to deal 39413fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// with potentially dead constants hanging off of the globals. 39513fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattnervoid Constant::removeDeadConstantUsers() const { 39613fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner Value::const_use_iterator I = use_begin(), E = use_end(); 39713fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner Value::const_use_iterator LastNonDeadUser = E; 39813fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner while (I != E) { 39913fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner const Constant *User = dyn_cast<Constant>(*I); 40013fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (User == 0) { 40113fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner LastNonDeadUser = I; 40213fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner ++I; 40313fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner continue; 40413fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } 405a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 40613fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (!removeDeadUsersOfConstant(User)) { 40713fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner // If the constant wasn't dead, remember that this was the last live use 40813fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner // and move on to the next constant. 40913fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner LastNonDeadUser = I; 41013fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner ++I; 41113fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner continue; 41213fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } 413a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 41413fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner // If the constant was dead, then the iterator is invalidated. 41513fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (LastNonDeadUser == E) { 41613fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner I = use_begin(); 41713fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (I == E) break; 41813fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } else { 41913fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner I = LastNonDeadUser; 42013fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner ++I; 42113fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } 42213fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } 42313fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner} 42413fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner 42513fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner 4268638144825f43fe59b0e1b78d65d93f0a7b737a7Chris Lattner 427009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 4286b6f6ba66c656b205a6db0751685911032fe710eChris Lattner// ConstantInt 429009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 430009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 4312d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid ConstantInt::anchor() { } 4322d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 433db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstantInt::ConstantInt(IntegerType *Ty, const APInt& V) 434eb41bddfdf6378ce407af2c03ee21fb1227eceecChris Lattner : Constant(Ty, ConstantIntVal, 0, 0), Val(V) { 435532d0ce208809545dc46d2de70c0384c036470d1Reid Spencer assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type"); 436009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 437009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 438d01f50f42ce60207ed6d27fb1778e456d83be06cNick LewyckyConstantInt *ConstantInt::getTrue(LLVMContext &Context) { 4395defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson LLVMContextImpl *pImpl = Context.pImpl; 440f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer if (!pImpl->TheTrueVal) 441f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer pImpl->TheTrueVal = ConstantInt::get(Type::getInt1Ty(Context), 1); 442f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer return pImpl->TheTrueVal; 4435defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson} 4445defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson 445d01f50f42ce60207ed6d27fb1778e456d83be06cNick LewyckyConstantInt *ConstantInt::getFalse(LLVMContext &Context) { 4465defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson LLVMContextImpl *pImpl = Context.pImpl; 447f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer if (!pImpl->TheFalseVal) 448f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer pImpl->TheFalseVal = ConstantInt::get(Type::getInt1Ty(Context), 0); 449f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer return pImpl->TheFalseVal; 4505defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson} 4515defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson 452db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantInt::getTrue(Type *Ty) { 453db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *VTy = dyn_cast<VectorType>(Ty); 454d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky if (!VTy) { 455d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky assert(Ty->isIntegerTy(1) && "True must be i1 or vector of i1."); 456d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ConstantInt::getTrue(Ty->getContext()); 457d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky } 458d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky assert(VTy->getElementType()->isIntegerTy(1) && 459d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky "True must be vector of i1 or i1."); 4603c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), 4613c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner ConstantInt::getTrue(Ty->getContext())); 462d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky} 463d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky 464db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantInt::getFalse(Type *Ty) { 465db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *VTy = dyn_cast<VectorType>(Ty); 466d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky if (!VTy) { 467d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky assert(Ty->isIntegerTy(1) && "False must be i1 or vector of i1."); 468d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ConstantInt::getFalse(Ty->getContext()); 469d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky } 470d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky assert(VTy->getElementType()->isIntegerTy(1) && 471d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky "False must be vector of i1 or i1."); 4723c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), 4733c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner ConstantInt::getFalse(Ty->getContext())); 474d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky} 475d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky 4765defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson 477eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// Get a ConstantInt from an APInt. Note that the value stored in the DenseMap 478eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// as the key, is a DenseMapAPIntKeyInfo::KeyTy which has provided the 479eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// operator== and operator!= to ensure that the DenseMap doesn't attempt to 480eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// compare APInt's of different widths, which would violate an APInt class 481eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// invariant which generates an assertion. 482d01f50f42ce60207ed6d27fb1778e456d83be06cNick LewyckyConstantInt *ConstantInt::get(LLVMContext &Context, const APInt &V) { 483eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Get the corresponding integer type for the bit width of the value. 484db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *ITy = IntegerType::get(Context, V.getBitWidth()); 485eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // get an existing value or the insertion position 4866dd56e60b002e5f3317bcc461be7fb8f6b19bbf5Benjamin Kramer LLVMContextImpl *pImpl = Context.pImpl; 4876dd56e60b002e5f3317bcc461be7fb8f6b19bbf5Benjamin Kramer ConstantInt *&Slot = pImpl->IntConstants[DenseMapAPIntKeyInfo::KeyTy(V, ITy)]; 48859d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson if (!Slot) Slot = new ConstantInt(ITy, V); 48959d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson return Slot; 490eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 491eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 492db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) { 493d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned); 494eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 495eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // For vectors, broadcast the value. 496db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 4973c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), C); 498eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 499eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return C; 500eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 501eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 502a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V, 503eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson bool isSigned) { 504eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned)); 505eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 506eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 507a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstantInt *ConstantInt::getSigned(IntegerType *Ty, int64_t V) { 508eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return get(Ty, V, true); 509eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 510eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 511db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantInt::getSigned(Type *Ty, int64_t V) { 512eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return get(Ty, V, true); 513eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 514eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 515a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstant *ConstantInt::get(Type *Ty, const APInt& V) { 516eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantInt *C = get(Ty->getContext(), V); 517eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(C->getType() == Ty->getScalarType() && 518eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson "ConstantInt type doesn't match the type implied by its value!"); 519eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 520eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // For vectors, broadcast the value. 521db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 5223c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), C); 523eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 524eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return C; 525eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 526eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 527a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstantInt *ConstantInt::get(IntegerType* Ty, StringRef Str, 5280e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar uint8_t radix) { 5290e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix)); 5300e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar} 5310e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 5326b6f6ba66c656b205a6db0751685911032fe710eChris Lattner//===----------------------------------------------------------------------===// 5339b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner// ConstantFP 5346b6f6ba66c656b205a6db0751685911032fe710eChris Lattner//===----------------------------------------------------------------------===// 5356b6f6ba66c656b205a6db0751685911032fe710eChris Lattner 536db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic const fltSemantics *TypeToFloatSemantics(Type *Ty) { 537ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman if (Ty->isHalfTy()) 538ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return &APFloat::IEEEhalf; 539cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isFloatTy()) 54087d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola return &APFloat::IEEEsingle; 541cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isDoubleTy()) 54287d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola return &APFloat::IEEEdouble; 543cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isX86_FP80Ty()) 54487d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola return &APFloat::x87DoubleExtended; 545cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (Ty->isFP128Ty()) 54687d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola return &APFloat::IEEEquad; 547a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 548cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner assert(Ty->isPPC_FP128Ty() && "Unknown FP format"); 54987d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola return &APFloat::PPCDoubleDouble; 55087d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola} 55187d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola 5522d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid ConstantFP::anchor() { } 5532d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 5546f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson/// get() - This returns a constant fp for the specified value in the 5556f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson/// specified type. This should only be used for simple constant values like 5566f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson/// 2.0/1.0 etc, that are known-valid both as double and as the target format. 557a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstant *ConstantFP::get(Type *Ty, double V) { 5586f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson LLVMContext &Context = Ty->getContext(); 559a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 5606f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson APFloat FV(V); 5616f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson bool ignored; 5626f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson FV.convert(*TypeToFloatSemantics(Ty->getScalarType()), 5636f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson APFloat::rmNearestTiesToEven, &ignored); 5646f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson Constant *C = get(Context, FV); 5656f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 5666f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson // For vectors, broadcast the value. 567db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 5683c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), C); 5696f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 5706f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return C; 5716f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson} 5726f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 5730e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 574a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstant *ConstantFP::get(Type *Ty, StringRef Str) { 5750e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar LLVMContext &Context = Ty->getContext(); 5760e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 5770e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar APFloat FV(*TypeToFloatSemantics(Ty->getScalarType()), Str); 5780e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar Constant *C = get(Context, FV); 5790e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 5800e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar // For vectors, broadcast the value. 581db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 5823c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), C); 5830e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 5840e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar return C; 5850e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar} 5860e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 5870e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 5883c2c954e0baf4c5029f87277d75cc6ca38916f71Chris LattnerConstantFP *ConstantFP::getNegativeZero(Type *Ty) { 5896f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson LLVMContext &Context = Ty->getContext(); 5903c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner APFloat apf = cast<ConstantFP>(Constant::getNullValue(Ty))->getValueAPF(); 5916f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson apf.changeSign(); 5926f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return get(Context, apf); 5936f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson} 5946f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 5956f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 5963c2c954e0baf4c5029f87277d75cc6ca38916f71Chris LattnerConstant *ConstantFP::getZeroValueForNegation(Type *Ty) { 5973c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner Type *ScalarTy = Ty->getScalarType(); 5983c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner if (ScalarTy->isFloatingPointTy()) { 5993c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner Constant *C = getNegativeZero(ScalarTy); 6003c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 6013c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), C); 6023c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return C; 6033c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner } 6046f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 605a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return Constant::getNullValue(Ty); 6066f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson} 6076f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 6086f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 6096f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson// ConstantFP accessors. 6106f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen AndersonConstantFP* ConstantFP::get(LLVMContext &Context, const APFloat& V) { 6116f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson LLVMContextImpl* pImpl = Context.pImpl; 612a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 6136dd56e60b002e5f3317bcc461be7fb8f6b19bbf5Benjamin Kramer ConstantFP *&Slot = pImpl->FPConstants[DenseMapAPFloatKeyInfo::KeyTy(V)]; 614a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 6156f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson if (!Slot) { 616db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty; 617ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman if (&V.getSemantics() == &APFloat::IEEEhalf) 618ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman Ty = Type::getHalfTy(Context); 619ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman else if (&V.getSemantics() == &APFloat::IEEEsingle) 62059d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Ty = Type::getFloatTy(Context); 62159d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson else if (&V.getSemantics() == &APFloat::IEEEdouble) 62259d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Ty = Type::getDoubleTy(Context); 62359d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson else if (&V.getSemantics() == &APFloat::x87DoubleExtended) 62459d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Ty = Type::getX86_FP80Ty(Context); 62559d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson else if (&V.getSemantics() == &APFloat::IEEEquad) 62659d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Ty = Type::getFP128Ty(Context); 62759d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson else { 62859d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson assert(&V.getSemantics() == &APFloat::PPCDoubleDouble && 62959d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson "Unknown FP format"); 63059d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Ty = Type::getPPC_FP128Ty(Context); 6316f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson } 63259d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Slot = new ConstantFP(Ty, V); 6336f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson } 634a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 6356f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return Slot; 6366f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson} 6376f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 638db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstantFP *ConstantFP::getInfinity(Type *Ty, bool Negative) { 639f344f7f008b69ea1e711c2cf80be9e660e40ee13Dan Gohman const fltSemantics &Semantics = *TypeToFloatSemantics(Ty); 640f344f7f008b69ea1e711c2cf80be9e660e40ee13Dan Gohman return ConstantFP::get(Ty->getContext(), 641f344f7f008b69ea1e711c2cf80be9e660e40ee13Dan Gohman APFloat::getInf(Semantics, Negative)); 642f344f7f008b69ea1e711c2cf80be9e660e40ee13Dan Gohman} 643f344f7f008b69ea1e711c2cf80be9e660e40ee13Dan Gohman 644db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstantFP::ConstantFP(Type *Ty, const APFloat& V) 645f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen : Constant(Ty, ConstantFPVal, 0, 0), Val(V) { 646288e78fbe7704d01bace67df88002f33c82e7ab5Chris Lattner assert(&V.getSemantics() == TypeToFloatSemantics(Ty) && 647288e78fbe7704d01bace67df88002f33c82e7ab5Chris Lattner "FP type Mismatch"); 648009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 649009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 650032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattnerbool ConstantFP::isExactlyValue(const APFloat &V) const { 651f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen return Val.bitwiseIsEqual(V); 6529b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner} 6539b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner 6549b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner//===----------------------------------------------------------------------===// 655ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner// ConstantAggregateZero Implementation 656ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner//===----------------------------------------------------------------------===// 657ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 658ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getSequentialElement - If this CAZ has array or vector type, return a zero 659ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// with the right element type. 6603d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *ConstantAggregateZero::getSequentialElement() const { 661230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return Constant::getNullValue(getType()->getSequentialElementType()); 662ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 663ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 664ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getStructElement - If this CAZ has struct type, return a zero with the 665ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// right element type for the specified element. 6663d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *ConstantAggregateZero::getStructElement(unsigned Elt) const { 667230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return Constant::getNullValue(getType()->getStructElementType(Elt)); 668ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 669ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 670ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getElementValue - Return a zero of the right value for the specified GEP 671ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// index if we can, otherwise return null (e.g. if C is a ConstantExpr). 6723d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *ConstantAggregateZero::getElementValue(Constant *C) const { 673ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner if (isa<SequentialType>(getType())) 674ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner return getSequentialElement(); 675ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner return getStructElement(cast<ConstantInt>(C)->getZExtValue()); 676ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 677ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 678df39028607ca751f0a3f50a76144464b825ff97aChris Lattner/// getElementValue - Return a zero of the right value for the specified GEP 679df39028607ca751f0a3f50a76144464b825ff97aChris Lattner/// index. 6803d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *ConstantAggregateZero::getElementValue(unsigned Idx) const { 681df39028607ca751f0a3f50a76144464b825ff97aChris Lattner if (isa<SequentialType>(getType())) 682df39028607ca751f0a3f50a76144464b825ff97aChris Lattner return getSequentialElement(); 683df39028607ca751f0a3f50a76144464b825ff97aChris Lattner return getStructElement(Idx); 684df39028607ca751f0a3f50a76144464b825ff97aChris Lattner} 685df39028607ca751f0a3f50a76144464b825ff97aChris Lattner 686df39028607ca751f0a3f50a76144464b825ff97aChris Lattner 687ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner//===----------------------------------------------------------------------===// 688ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner// UndefValue Implementation 689ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner//===----------------------------------------------------------------------===// 690ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 691ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getSequentialElement - If this undef has array or vector type, return an 692ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// undef with the right element type. 6933d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerUndefValue *UndefValue::getSequentialElement() const { 694230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return UndefValue::get(getType()->getSequentialElementType()); 695ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 696ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 697ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getStructElement - If this undef has struct type, return a zero with the 698ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// right element type for the specified element. 6993d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerUndefValue *UndefValue::getStructElement(unsigned Elt) const { 700230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return UndefValue::get(getType()->getStructElementType(Elt)); 701ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 702ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 703ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getElementValue - Return an undef of the right value for the specified GEP 704ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// index if we can, otherwise return null (e.g. if C is a ConstantExpr). 7053d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerUndefValue *UndefValue::getElementValue(Constant *C) const { 706ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner if (isa<SequentialType>(getType())) 707ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner return getSequentialElement(); 708ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner return getStructElement(cast<ConstantInt>(C)->getZExtValue()); 709ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 710ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 711df39028607ca751f0a3f50a76144464b825ff97aChris Lattner/// getElementValue - Return an undef of the right value for the specified GEP 712df39028607ca751f0a3f50a76144464b825ff97aChris Lattner/// index. 7133d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerUndefValue *UndefValue::getElementValue(unsigned Idx) const { 714df39028607ca751f0a3f50a76144464b825ff97aChris Lattner if (isa<SequentialType>(getType())) 715df39028607ca751f0a3f50a76144464b825ff97aChris Lattner return getSequentialElement(); 716df39028607ca751f0a3f50a76144464b825ff97aChris Lattner return getStructElement(Idx); 717df39028607ca751f0a3f50a76144464b825ff97aChris Lattner} 718df39028607ca751f0a3f50a76144464b825ff97aChris Lattner 719df39028607ca751f0a3f50a76144464b825ff97aChris Lattner 720ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 721ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner//===----------------------------------------------------------------------===// 7229b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner// ConstantXXX Classes 7239b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner//===----------------------------------------------------------------------===// 7249b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner 72518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattnertemplate <typename ItTy, typename EltTy> 72618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattnerstatic bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt) { 72718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (; Start != End; ++Start) 72818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (*Start != Elt) 72918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return false; 73018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return true; 73118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner} 7329b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner 733166579e287a38d907acafc24243146e9f3ee9799Jay FoadConstantArray::ConstantArray(ArrayType *T, ArrayRef<Constant *> V) 734efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif : Constant(T, ConstantArrayVal, 735efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif OperandTraits<ConstantArray>::op_end(this) - V.size(), 736efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif V.size()) { 737e0de1d64be1a20c7b617d99e11bacbb0325f5bb6Alkis Evlogimenos assert(V.size() == T->getNumElements() && 738e0de1d64be1a20c7b617d99e11bacbb0325f5bb6Alkis Evlogimenos "Invalid initializer vector for constant array"); 739166579e287a38d907acafc24243146e9f3ee9799Jay Foad for (unsigned i = 0, e = V.size(); i != e; ++i) 740166579e287a38d907acafc24243146e9f3ee9799Jay Foad assert(V[i]->getType() == T->getElementType() && 741cad90ad162daf81c0d8e45b856bb9152abea4db3Alkis Evlogimenos "Initializer for array element doesn't match array element type!"); 742166579e287a38d907acafc24243146e9f3ee9799Jay Foad std::copy(V.begin(), V.end(), op_begin()); 743009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 744009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 745db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantArray::get(ArrayType *Ty, ArrayRef<Constant*> V) { 74618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // Empty arrays are canonicalized to ConstantAggregateZero. 74718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (V.empty()) 74818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantAggregateZero::get(Ty); 74918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner 7501fb613c43de4dc6d6955be6054a7300de8f2d79bJeffrey Yasskin for (unsigned i = 0, e = V.size(); i != e; ++i) { 7511fb613c43de4dc6d6955be6054a7300de8f2d79bJeffrey Yasskin assert(V[i]->getType() == Ty->getElementType() && 7521fb613c43de4dc6d6955be6054a7300de8f2d79bJeffrey Yasskin "Wrong type in array element initializer"); 7531fb613c43de4dc6d6955be6054a7300de8f2d79bJeffrey Yasskin } 7541fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson LLVMContextImpl *pImpl = Ty->getContext().pImpl; 755a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 75618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // If this is an all-zero array, return a ConstantAggregateZero object. If 75718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // all undef, return an UndefValue, if "all simple", then return a 75818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // ConstantDataArray. 75918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Constant *C = V[0]; 76018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (isa<UndefValue>(C) && rangeOnlyContains(V.begin(), V.end(), C)) 76191766fe066efe6e0969ba805a2e3726a70ed34a3Argyrios Kyrtzidis return UndefValue::get(Ty); 7623ef9cfef13d7c7208b98b2d9995c3df6dcfe0d99Chris Lattner 76318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (C->isNullValue() && rangeOnlyContains(V.begin(), V.end(), C)) 76418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantAggregateZero::get(Ty); 7653ef9cfef13d7c7208b98b2d9995c3df6dcfe0d99Chris Lattner 76618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // Check to see if all of the elements are ConstantFP or ConstantInt and if 76718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // the element type is compatible with ConstantDataVector. If so, use it. 76818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantDataSequential::isElementTypeCompatible(C->getType())) { 76918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // We speculatively build the elements here even if it turns out that there 77018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // is a constantexpr or something else weird in the array, since it is so 77118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // uncommon for that to happen. 77218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) { 77318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (CI->getType()->isIntegerTy(8)) { 77418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<uint8_t, 16> Elts; 77518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 77618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 77718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CI->getZExtValue()); 77818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 77918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 78018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 78118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 78218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } else if (CI->getType()->isIntegerTy(16)) { 78318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<uint16_t, 16> Elts; 78418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 78518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 78618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CI->getZExtValue()); 78718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 78818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 78918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 79018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 79118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } else if (CI->getType()->isIntegerTy(32)) { 79218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<uint32_t, 16> Elts; 79318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 79418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 79518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CI->getZExtValue()); 79618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 79718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 79818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 79918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 80018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } else if (CI->getType()->isIntegerTy(64)) { 80118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<uint64_t, 16> Elts; 80218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 80318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 80418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CI->getZExtValue()); 80518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 80618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 80718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 80818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 80918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } 81018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } 811a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 81218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 81318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (CFP->getType()->isFloatTy()) { 81418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<float, 16> Elts; 81518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 81618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) 81718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CFP->getValueAPF().convertToFloat()); 81818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 81918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 82018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 82118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 82218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } else if (CFP->getType()->isDoubleTy()) { 82318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<double, 16> Elts; 82418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 82518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) 82618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CFP->getValueAPF().convertToDouble()); 82718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 82818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 82918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 83018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 83118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } 83218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } 83318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } 83491766fe066efe6e0969ba805a2e3726a70ed34a3Argyrios Kyrtzidis 83518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // Otherwise, we really do want to create a ConstantArray. 83618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return pImpl->ArrayConstants.getOrCreate(Ty, V); 8371fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson} 8381fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson 839b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner/// getTypeForElements - Return an anonymous struct type to use for a constant 840b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner/// with the specified set of elements. The list must not be empty. 841b065b06c12dba6001b8140df2744d0c856ef6ea1Chris LattnerStructType *ConstantStruct::getTypeForElements(LLVMContext &Context, 842b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner ArrayRef<Constant*> V, 843b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner bool Packed) { 844a7a3f04eb9a18c11940ab1486709c63c8bd296ffBill Wendling unsigned VecSize = V.size(); 845a7a3f04eb9a18c11940ab1486709c63c8bd296ffBill Wendling SmallVector<Type*, 16> EltTypes(VecSize); 846a7a3f04eb9a18c11940ab1486709c63c8bd296ffBill Wendling for (unsigned i = 0; i != VecSize; ++i) 847a7a3f04eb9a18c11940ab1486709c63c8bd296ffBill Wendling EltTypes[i] = V[i]->getType(); 848a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 849b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner return StructType::get(Context, EltTypes, Packed); 850b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner} 851b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner 852b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner 853b065b06c12dba6001b8140df2744d0c856ef6ea1Chris LattnerStructType *ConstantStruct::getTypeForElements(ArrayRef<Constant*> V, 854b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner bool Packed) { 855b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner assert(!V.empty() && 856b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner "ConstantStruct::getTypeForElements cannot be called on empty list"); 857b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner return getTypeForElements(V[0]->getContext(), V, Packed); 858b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner} 859b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner 860b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner 861166579e287a38d907acafc24243146e9f3ee9799Jay FoadConstantStruct::ConstantStruct(StructType *T, ArrayRef<Constant *> V) 862efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif : Constant(T, ConstantStructVal, 863efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif OperandTraits<ConstantStruct>::op_end(this) - V.size(), 864efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif V.size()) { 865f4ef8db7cd71edabe424f9d5c7d3ee23ef9924d5Chris Lattner assert(V.size() == T->getNumElements() && 866345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve "Invalid initializer vector for constant structure"); 867166579e287a38d907acafc24243146e9f3ee9799Jay Foad for (unsigned i = 0, e = V.size(); i != e; ++i) 868166579e287a38d907acafc24243146e9f3ee9799Jay Foad assert((T->isOpaque() || V[i]->getType() == T->getElementType(i)) && 869b84388937cbe7d5cb32a39e649ef020d4d7e5cb5Chris Lattner "Initializer for struct element doesn't match struct element type!"); 870166579e287a38d907acafc24243146e9f3ee9799Jay Foad std::copy(V.begin(), V.end(), op_begin()); 871009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 872009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 8738fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson// ConstantStruct accessors. 874db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantStruct::get(StructType *ST, ArrayRef<Constant*> V) { 8751afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert((ST->isOpaque() || ST->getNumElements() == V.size()) && 8761afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner "Incorrect # elements specified to ConstantStruct::get"); 877e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner 878e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner // Create a ConstantAggregateZero value if all elements are zeros. 879e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner bool isZero = true; 880e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner bool isUndef = false; 881e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner 882e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (!V.empty()) { 883e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner isUndef = isa<UndefValue>(V[0]); 884e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner isZero = V[0]->isNullValue(); 885e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (isUndef || isZero) { 886e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) { 887e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (!V[i]->isNullValue()) 888e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner isZero = false; 889e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (!isa<UndefValue>(V[i])) 890e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner isUndef = false; 891e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } 892e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } 893a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova } 894e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (isZero) 895e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner return ConstantAggregateZero::get(ST); 896e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (isUndef) 897e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner return UndefValue::get(ST); 898a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 899e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner return ST->getContext().pImpl->StructConstants.getOrCreate(ST, V); 9008fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson} 901e467147b30a10f2687a8ed9c8895a8eb846b50bbChris Lattner 902f4ef8db7cd71edabe424f9d5c7d3ee23ef9924d5Chris LattnerConstant *ConstantStruct::get(StructType *T, ...) { 90341ee4e57ea0f2afb89fd136065edb03f32f972d3Talin va_list ap; 904b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner SmallVector<Constant*, 8> Values; 905b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner va_start(ap, T); 906b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner while (Constant *Val = va_arg(ap, llvm::Constant*)) 90741ee4e57ea0f2afb89fd136065edb03f32f972d3Talin Values.push_back(Val); 908bdcd766028bc17e83f1312e3e52b1d9b22c6a624Talin va_end(ap); 909b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner return get(T, Values); 91041ee4e57ea0f2afb89fd136065edb03f32f972d3Talin} 91141ee4e57ea0f2afb89fd136065edb03f32f972d3Talin 912166579e287a38d907acafc24243146e9f3ee9799Jay FoadConstantVector::ConstantVector(VectorType *T, ArrayRef<Constant *> V) 913efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif : Constant(T, ConstantVectorVal, 914efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif OperandTraits<ConstantVector>::op_end(this) - V.size(), 915efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif V.size()) { 916166579e287a38d907acafc24243146e9f3ee9799Jay Foad for (size_t i = 0, e = V.size(); i != e; i++) 917166579e287a38d907acafc24243146e9f3ee9799Jay Foad assert(V[i]->getType() == T->getElementType() && 918fa73ea2d9fd785a214256ca44488407b26c5a3dbDan Gohman "Initializer for vector element doesn't match vector element type!"); 919166579e287a38d907acafc24243146e9f3ee9799Jay Foad std::copy(V.begin(), V.end(), op_begin()); 920715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke} 921715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke 922af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson// ConstantVector accessors. 923a0c138429e101f573d43740322245c1d5b8b04a0Jay FoadConstant *ConstantVector::get(ArrayRef<Constant*> V) { 9249afc527671618e6cd878c29f5a3ac63598486994Jay Foad assert(!V.empty() && "Vectors can't be empty"); 925db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *T = VectorType::get(V.front()->getType(), V.size()); 9262ca5c8644e6c35b3a7910a576ed89cddb7b82c3bChris Lattner LLVMContextImpl *pImpl = T->getContext().pImpl; 9279afc527671618e6cd878c29f5a3ac63598486994Jay Foad 9282ca5c8644e6c35b3a7910a576ed89cddb7b82c3bChris Lattner // If this is an all-undef or all-zero vector, return a 929af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson // ConstantAggregateZero or UndefValue. 930af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson Constant *C = V[0]; 931af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson bool isZero = C->isNullValue(); 932af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson bool isUndef = isa<UndefValue>(C); 933af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson 934af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson if (isZero || isUndef) { 935af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson for (unsigned i = 1, e = V.size(); i != e; ++i) 936af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson if (V[i] != C) { 937af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson isZero = isUndef = false; 938af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson break; 939af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson } 940af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson } 941a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 942af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson if (isZero) 9439e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson return ConstantAggregateZero::get(T); 944af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson if (isUndef) 9459e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson return UndefValue::get(T); 946a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 94736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // Check to see if all of the elements are ConstantFP or ConstantInt and if 94836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // the element type is compatible with ConstantDataVector. If so, use it. 94918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantDataSequential::isElementTypeCompatible(C->getType())) { 95036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // We speculatively build the elements here even if it turns out that there 95136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // is a constantexpr or something else weird in the array, since it is so 95236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // uncommon for that to happen. 95336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) { 95436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (CI->getType()->isIntegerTy(8)) { 95536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<uint8_t, 16> Elts; 95636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 95736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 95836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CI->getZExtValue()); 95936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 96036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 96136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 96236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 96336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } else if (CI->getType()->isIntegerTy(16)) { 96436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<uint16_t, 16> Elts; 96536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 96636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 96736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CI->getZExtValue()); 96836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 96936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 97036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 97136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 97236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } else if (CI->getType()->isIntegerTy(32)) { 97336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<uint32_t, 16> Elts; 97436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 97536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 97636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CI->getZExtValue()); 97736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 97836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 97936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 98036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 98136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } else if (CI->getType()->isIntegerTy(64)) { 98236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<uint64_t, 16> Elts; 98336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 98436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 98536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CI->getZExtValue()); 98636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 98736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 98836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 98936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 99036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 99136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 992a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 99336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 99436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (CFP->getType()->isFloatTy()) { 99536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<float, 16> Elts; 99636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 99736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) 99836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CFP->getValueAPF().convertToFloat()); 99936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 100036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 100136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 100236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 100336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } else if (CFP->getType()->isDoubleTy()) { 100436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<double, 16> Elts; 100536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 100636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) 100736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CFP->getValueAPF().convertToDouble()); 100836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 100936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 101036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 101136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 101236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 101336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 101436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 1015a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 101636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // Otherwise, the element type isn't compatible with ConstantDataVector, or 101736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // the operand list constants a ConstantExpr or something else strange. 1018af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson return pImpl->VectorConstants.getOrCreate(T, V); 1019af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson} 1020af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson 10213c2c954e0baf4c5029f87277d75cc6ca38916f71Chris LattnerConstant *ConstantVector::getSplat(unsigned NumElts, Constant *V) { 102236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // If this splat is compatible with ConstantDataVector, use it instead of 102336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // ConstantVector. 102436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if ((isa<ConstantFP>(V) || isa<ConstantInt>(V)) && 102536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner ConstantDataSequential::isElementTypeCompatible(V->getType())) 102636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::getSplat(NumElts, V); 1027a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 10283c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner SmallVector<Constant*, 32> Elts(NumElts, V); 10293c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return get(Elts); 10303c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner} 10313c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner 10323c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner 10333da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer// Utility function for determining if a ConstantExpr is a CastOp or not. This 10343da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer// can't be inline because we don't want to #include Instruction.h into 10353da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer// Constant.h 10363da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencerbool ConstantExpr::isCast() const { 10373da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer return Instruction::isCast(getOpcode()); 10383da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 10393da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1040077d0eb1bd54b71143139a5184d291454d638ebcReid Spencerbool ConstantExpr::isCompare() const { 10417f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp; 1042077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer} 1043077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1044e6992f728a94654e43269580a10a667f18dadba9Dan Gohmanbool ConstantExpr::isGEPWithNoNotionalOverIndexing() const { 1045e6992f728a94654e43269580a10a667f18dadba9Dan Gohman if (getOpcode() != Instruction::GetElementPtr) return false; 1046e6992f728a94654e43269580a10a667f18dadba9Dan Gohman 1047e6992f728a94654e43269580a10a667f18dadba9Dan Gohman gep_type_iterator GEPI = gep_type_begin(this), E = gep_type_end(this); 1048ee56c42168f6c4271593f6018c4409b6a5910302Oscar Fuentes User::const_op_iterator OI = llvm::next(this->op_begin()); 1049e6992f728a94654e43269580a10a667f18dadba9Dan Gohman 1050e6992f728a94654e43269580a10a667f18dadba9Dan Gohman // Skip the first index, as it has no static limit. 1051e6992f728a94654e43269580a10a667f18dadba9Dan Gohman ++GEPI; 1052e6992f728a94654e43269580a10a667f18dadba9Dan Gohman ++OI; 1053e6992f728a94654e43269580a10a667f18dadba9Dan Gohman 1054e6992f728a94654e43269580a10a667f18dadba9Dan Gohman // The remaining indices must be compile-time known integers within the 1055e6992f728a94654e43269580a10a667f18dadba9Dan Gohman // bounds of the corresponding notional static array types. 1056e6992f728a94654e43269580a10a667f18dadba9Dan Gohman for (; GEPI != E; ++GEPI, ++OI) { 1057e6992f728a94654e43269580a10a667f18dadba9Dan Gohman ConstantInt *CI = dyn_cast<ConstantInt>(*OI); 1058e6992f728a94654e43269580a10a667f18dadba9Dan Gohman if (!CI) return false; 1059db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *ATy = dyn_cast<ArrayType>(*GEPI)) 1060e6992f728a94654e43269580a10a667f18dadba9Dan Gohman if (CI->getValue().getActiveBits() > 64 || 1061e6992f728a94654e43269580a10a667f18dadba9Dan Gohman CI->getZExtValue() >= ATy->getNumElements()) 1062e6992f728a94654e43269580a10a667f18dadba9Dan Gohman return false; 1063e6992f728a94654e43269580a10a667f18dadba9Dan Gohman } 1064e6992f728a94654e43269580a10a667f18dadba9Dan Gohman 1065e6992f728a94654e43269580a10a667f18dadba9Dan Gohman // All the indices checked out. 1066e6992f728a94654e43269580a10a667f18dadba9Dan Gohman return true; 1067e6992f728a94654e43269580a10a667f18dadba9Dan Gohman} 1068e6992f728a94654e43269580a10a667f18dadba9Dan Gohman 106981a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohmanbool ConstantExpr::hasIndices() const { 107081a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman return getOpcode() == Instruction::ExtractValue || 107181a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman getOpcode() == Instruction::InsertValue; 107281a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman} 107381a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman 1074d30aa5a1edac5256573e8d76dd155df3d3fdec84Jay FoadArrayRef<unsigned> ConstantExpr::getIndices() const { 107581a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman if (const ExtractValueConstantExpr *EVCE = 107681a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman dyn_cast<ExtractValueConstantExpr>(this)) 107781a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman return EVCE->Indices; 10781a203571ca94c4770a8cada8ace7fbeb0e65799aDan Gohman 10791a203571ca94c4770a8cada8ace7fbeb0e65799aDan Gohman return cast<InsertValueConstantExpr>(this)->Indices; 108081a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman} 108181a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman 1082728b6db6fbd3caee7fa25b377f4592160476bb9cReid Spencerunsigned ConstantExpr::getPredicate() const { 10833e19473af308325801fbdd27abc56c8afcfde2cbChris Lattner assert(isCompare()); 1084b7daa84a3500105a9e5245b463155fcb15ed6730Chris Lattner return ((const CompareConstantExpr*)this)->predicate; 1085728b6db6fbd3caee7fa25b377f4592160476bb9cReid Spencer} 1086f4ba6c710c298fe9b492b9cde82ce5efd46afd5dChris Lattner 10871fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner/// getWithOperandReplaced - Return a constant expression identical to this 10881fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner/// one, but with the specified operand set to the specified value. 10893da59db637a887474c1b1346c1f3ccf53b6c4663Reid SpencerConstant * 10903da59db637a887474c1b1346c1f3ccf53b6c4663Reid SpencerConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const { 10911fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner assert(Op->getType() == getOperand(OpNo)->getType() && 10921fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner "Replacing operand with value of different type!"); 1093b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner if (getOperand(OpNo) == Op) 1094b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return const_cast<ConstantExpr*>(this); 10951a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner 10961a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner SmallVector<Constant*, 8> NewOps; 10971a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 10981a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner NewOps.push_back(i == OpNo ? Op : getOperand(i)); 1099a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 11001a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner return getWithOperands(NewOps); 1101b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner} 1102b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner 1103b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner/// getWithOperands - This returns the current constant expression with the 11041afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// operands replaced with the specified values. The specified array must 11051afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// have the same number of operands as our current one. 1106b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris LattnerConstant *ConstantExpr:: 1107db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnergetWithOperands(ArrayRef<Constant*> Ops, Type *Ty) const { 1108b81e457eb02b67a9ef5fb9edc1604b177acb821dJay Foad assert(Ops.size() == getNumOperands() && "Operand count mismatch!"); 11091afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool AnyChange = Ty != getType(); 11101afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (unsigned i = 0; i != Ops.size(); ++i) 1111b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner AnyChange |= Ops[i] != getOperand(i); 1112a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1113b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner if (!AnyChange) // No operands changed, return self. 1114b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return const_cast<ConstantExpr*>(this); 1115b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner 1116b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner switch (getOpcode()) { 11173da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::Trunc: 11183da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::ZExt: 11193da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::SExt: 11203da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::FPTrunc: 11213da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::FPExt: 11223da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::UIToFP: 11233da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::SIToFP: 11243da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::FPToUI: 11253da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::FPToSI: 11263da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::PtrToInt: 11273da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::IntToPtr: 11283da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::BitCast: 11291afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return ConstantExpr::getCast(getOpcode(), Ops[0], Ty); 11301fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner case Instruction::Select: 1131b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]); 11321fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner case Instruction::InsertElement: 1133b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]); 11341fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner case Instruction::ExtractElement: 1135b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return ConstantExpr::getExtractElement(Ops[0], Ops[1]); 11361a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner case Instruction::InsertValue: 11371a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner return ConstantExpr::getInsertValue(Ops[0], Ops[1], getIndices()); 11381a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner case Instruction::ExtractValue: 11391a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner return ConstantExpr::getExtractValue(Ops[0], getIndices()); 11401fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner case Instruction::ShuffleVector: 1141b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]); 1142f9021ff7407d3e979a15acc1e21da3e39e423936Chris Lattner case Instruction::GetElementPtr: 11431a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner return ConstantExpr::getGetElementPtr(Ops[0], Ops.slice(1), 11441a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner cast<GEPOperator>(this)->isInBounds()); 1145e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case Instruction::ICmp: 1146e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case Instruction::FCmp: 1147e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1]); 11481fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner default: 11491fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner assert(getNumOperands() == 2 && "Must be binary operator?"); 1150cafe9bba32aeed16e8e3db28b4cd4ff13160438fChris Lattner return ConstantExpr::get(getOpcode(), Ops[0], Ops[1], SubclassOptionalData); 11511fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner } 11521fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner} 11531fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner 1154009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1155009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1156009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// isValueValidForType implementations 1157009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1158db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerbool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) { 1159230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner unsigned NumBits = Ty->getIntegerBitWidth(); // assert okay 1160230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (Ty->isIntegerTy(1)) 1161a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Val == 0 || Val == 1; 1162554cec6e65fecdf3a14b3ddd1cb2c9615e726220Reid Spencer if (NumBits >= 64) 1163a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return true; // always true, has to fit in largest type 1164a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer uint64_t Max = (1ll << NumBits) - 1; 1165a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Val <= Max; 11669b11d518aef8e191e5e94f3503dfddbe1c0a387aReid Spencer} 11679b11d518aef8e191e5e94f3503dfddbe1c0a387aReid Spencer 1168db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerbool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) { 1169230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner unsigned NumBits = Ty->getIntegerBitWidth(); 1170230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (Ty->isIntegerTy(1)) 1171c10305743c313558405079452138f03124e87581Reid Spencer return Val == 0 || Val == 1 || Val == -1; 1172554cec6e65fecdf3a14b3ddd1cb2c9615e726220Reid Spencer if (NumBits >= 64) 1173a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return true; // always true, has to fit in largest type 1174a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer int64_t Min = -(1ll << (NumBits-1)); 1175a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer int64_t Max = (1ll << (NumBits-1)) - 1; 1176a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return (Val >= Min && Val <= Max); 1177009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1178009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1179db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerbool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) { 1180f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen // convert modifies in place, so make a copy. 1181f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen APFloat Val2 = APFloat(Val); 118223a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool losesInfo; 1183f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 1184009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner default: 1185009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner return false; // These can't be represented as floating point! 1186009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1187f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen // FIXME rounding mode needs to be more flexible 1188ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman case Type::HalfTyID: { 1189ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman if (&Val2.getSemantics() == &APFloat::IEEEhalf) 1190ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return true; 1191ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman Val2.convert(APFloat::IEEEhalf, APFloat::rmNearestTiesToEven, &losesInfo); 1192ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return !losesInfo; 1193ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman } 119423a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen case Type::FloatTyID: { 119523a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (&Val2.getSemantics() == &APFloat::IEEEsingle) 119623a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen return true; 119723a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen Val2.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo); 119823a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen return !losesInfo; 119923a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen } 120023a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen case Type::DoubleTyID: { 1201ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman if (&Val2.getSemantics() == &APFloat::IEEEhalf || 1202ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman &Val2.getSemantics() == &APFloat::IEEEsingle || 120323a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen &Val2.getSemantics() == &APFloat::IEEEdouble) 120423a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen return true; 120523a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen Val2.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo); 120623a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen return !losesInfo; 120723a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen } 1208ebbc95da49c6f4ae09947a9f4ab6a8616ea40e3bDale Johannesen case Type::X86_FP80TyID: 1209ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return &Val2.getSemantics() == &APFloat::IEEEhalf || 1210ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman &Val2.getSemantics() == &APFloat::IEEEsingle || 12119d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen &Val2.getSemantics() == &APFloat::IEEEdouble || 12129d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen &Val2.getSemantics() == &APFloat::x87DoubleExtended; 1213ebbc95da49c6f4ae09947a9f4ab6a8616ea40e3bDale Johannesen case Type::FP128TyID: 1214ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return &Val2.getSemantics() == &APFloat::IEEEhalf || 1215ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman &Val2.getSemantics() == &APFloat::IEEEsingle || 12169d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen &Val2.getSemantics() == &APFloat::IEEEdouble || 12179d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen &Val2.getSemantics() == &APFloat::IEEEquad; 1218a471c2ecda37cd1bae0d94e832f002caa7b63216Dale Johannesen case Type::PPC_FP128TyID: 1219ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return &Val2.getSemantics() == &APFloat::IEEEhalf || 1220ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman &Val2.getSemantics() == &APFloat::IEEEsingle || 1221a471c2ecda37cd1bae0d94e832f002caa7b63216Dale Johannesen &Val2.getSemantics() == &APFloat::IEEEdouble || 1222a471c2ecda37cd1bae0d94e832f002caa7b63216Dale Johannesen &Val2.getSemantics() == &APFloat::PPCDoubleDouble; 1223009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1224d74ea2bbd8bb630331f35ead42d385249bd42af8Chris Lattner} 122537bf6308ab839cfc85cc864b99d3e35651b66d94Chris Lattner 1226ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 1227531daef1542fd6a958c509ccbb6390d33496aae9Chris Lattner//===----------------------------------------------------------------------===// 1228531daef1542fd6a958c509ccbb6390d33496aae9Chris Lattner// Factory Function Implementation 1229531daef1542fd6a958c509ccbb6390d33496aae9Chris Lattner 12309df0fb4e8176325d713ba4eb67791e36cb833432Chris LattnerConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) { 123161c70e98ac3c7504d31dd9bc81c4e9cb998e9984Chris Lattner assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) && 12329e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson "Cannot create an aggregate zero of non-aggregate type!"); 12339e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson 12349df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner ConstantAggregateZero *&Entry = Ty->getContext().pImpl->CAZConstants[Ty]; 12359df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner if (Entry == 0) 12369df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner Entry = new ConstantAggregateZero(Ty); 1237a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 12389df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner return Entry; 12399e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson} 12409e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson 1241ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// destroyConstant - Remove the constant from the constant table. 12420f8b53f19d29013ab18f3d444cea1e6305405611Dan Gohman/// 124304fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantAggregateZero::destroyConstant() { 12449df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner getContext().pImpl->CAZConstants.erase(getType()); 124540bbeb5d077b1bc2b933d8c8628024dfa9b428c3Chris Lattner destroyConstantImpl(); 124640bbeb5d077b1bc2b933d8c8628024dfa9b428c3Chris Lattner} 124740bbeb5d077b1bc2b933d8c8628024dfa9b428c3Chris Lattner 12480f8b53f19d29013ab18f3d444cea1e6305405611Dan Gohman/// destroyConstant - Remove the constant from the constant table... 12490f8b53f19d29013ab18f3d444cea1e6305405611Dan Gohman/// 125004fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantArray::destroyConstant() { 12511afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner getType()->getContext().pImpl->ArrayConstants.remove(this); 125202ec5ede6cf10163086a27241508fc5778e39737Chris Lattner destroyConstantImpl(); 125302ec5ede6cf10163086a27241508fc5778e39737Chris Lattner} 125402ec5ede6cf10163086a27241508fc5778e39737Chris Lattner 125593aeea3748b11fa213b345edf3c86275a4936a31Chris Lattner 1256e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner//---- ConstantStruct::get() implementation... 1257531daef1542fd6a958c509ccbb6390d33496aae9Chris Lattner// 1258ed468e37a1b15e17e0fd44e0b39bd53bc4174e69Chris Lattner 1259f5ec48d7b5260089e2f3da65508999dcc19f14ceChris Lattner// destroyConstant - Remove the constant from the constant table... 1260f5ec48d7b5260089e2f3da65508999dcc19f14ceChris Lattner// 126104fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantStruct::destroyConstant() { 12621afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner getType()->getContext().pImpl->StructConstants.remove(this); 1263f5ec48d7b5260089e2f3da65508999dcc19f14ceChris Lattner destroyConstantImpl(); 1264f5ec48d7b5260089e2f3da65508999dcc19f14ceChris Lattner} 1265f5ec48d7b5260089e2f3da65508999dcc19f14ceChris Lattner 1266715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke// destroyConstant - Remove the constant from the constant table... 1267715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke// 126804fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantVector::destroyConstant() { 12691afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner getType()->getContext().pImpl->VectorConstants.remove(this); 1270715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke destroyConstantImpl(); 1271715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke} 1272715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke 12732333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands/// getSplatValue - If this is a splat vector constant, meaning that all of 12742333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands/// the elements have the same value, return that value. Otherwise return 0. 12752333e29be441d9d55920651e0b2add23ab0c1613Duncan SandsConstant *Constant::getSplatValue() const { 12762333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert(this->getType()->isVectorTy() && "Only valid for vectors!"); 12772333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands if (isa<ConstantAggregateZero>(this)) 12782333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands return getNullValue(this->getType()->getVectorElementType()); 12792333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) 12802333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands return CV->getSplatValue(); 12812333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) 12822333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands return CV->getSplatValue(); 12832333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands return 0; 12842333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands} 12852333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands 12863b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman/// getSplatValue - If this is a splat constant, where all of the 12873b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman/// elements have the same value, return that value. Otherwise return null. 12887681c6da606efcc392f76b8acea8301cb5fc7a0aDuncan SandsConstant *ConstantVector::getSplatValue() const { 12893b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman // Check out first element. 12903b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman Constant *Elt = getOperand(0); 12913b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman // Then make sure all remaining elements point to the same value. 12923b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman for (unsigned I = 1, E = getNumOperands(); I < E; ++I) 12933e19473af308325801fbdd27abc56c8afcfde2cbChris Lattner if (getOperand(I) != Elt) 12943e19473af308325801fbdd27abc56c8afcfde2cbChris Lattner return 0; 12953b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman return Elt; 12963b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman} 12973b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman 12982333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands/// If C is a constant integer then return its value, otherwise C must be a 12992333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands/// vector of constant integers, all equal, and the common value is returned. 13002333e29be441d9d55920651e0b2add23ab0c1613Duncan Sandsconst APInt &Constant::getUniqueInteger() const { 13012333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands if (const ConstantInt *CI = dyn_cast<ConstantInt>(this)) 13022333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands return CI->getValue(); 13032333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert(this->getSplatValue() && "Doesn't contain a unique integer!"); 13042333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands const Constant *C = this->getAggregateElement(0U); 13052333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert(C && isa<ConstantInt>(C) && "Not a vector of numbers!"); 13062333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands return cast<ConstantInt>(C)->getValue(); 13072333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands} 13082333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands 13092333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands 13102ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner//---- ConstantPointerNull::get() implementation. 13116a57baa295bb3dbd389581df968536f594709bdbChris Lattner// 131202ec5ede6cf10163086a27241508fc5778e39737Chris Lattner 1313db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) { 13149df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner ConstantPointerNull *&Entry = Ty->getContext().pImpl->CPNConstants[Ty]; 13159df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner if (Entry == 0) 13169df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner Entry = new ConstantPointerNull(Ty); 1317a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 13189df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner return Entry; 13196a57baa295bb3dbd389581df968536f594709bdbChris Lattner} 13206a57baa295bb3dbd389581df968536f594709bdbChris Lattner 132141661fdb2e963610b399c8ebe51a507847ef997dChris Lattner// destroyConstant - Remove the constant from the constant table... 132241661fdb2e963610b399c8ebe51a507847ef997dChris Lattner// 132304fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantPointerNull::destroyConstant() { 13249df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner getContext().pImpl->CPNConstants.erase(getType()); 13259df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner // Free the constant and any dangling references to it. 132641661fdb2e963610b399c8ebe51a507847ef997dChris Lattner destroyConstantImpl(); 132741661fdb2e963610b399c8ebe51a507847ef997dChris Lattner} 132841661fdb2e963610b399c8ebe51a507847ef997dChris Lattner 132941661fdb2e963610b399c8ebe51a507847ef997dChris Lattner 13302ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner//---- UndefValue::get() implementation. 1331b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner// 1332b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner 1333db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerUndefValue *UndefValue::get(Type *Ty) { 13349df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner UndefValue *&Entry = Ty->getContext().pImpl->UVConstants[Ty]; 13359df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner if (Entry == 0) 13369df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner Entry = new UndefValue(Ty); 1337a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 13389df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner return Entry; 1339b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner} 1340b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner 1341b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner// destroyConstant - Remove the constant from the constant table. 1342b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner// 134304fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid UndefValue::destroyConstant() { 13449df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner // Free the constant and any dangling references to it. 13459df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner getContext().pImpl->UVConstants.erase(getType()); 1346b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner destroyConstantImpl(); 1347b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner} 1348b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner 13492ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner//---- BlockAddress::get() implementation. 13502ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner// 13512ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 13522ee11eccdde14c95c78773be76b02bb5fd09d7eeChris LattnerBlockAddress *BlockAddress::get(BasicBlock *BB) { 13532ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner assert(BB->getParent() != 0 && "Block must have a parent"); 13542ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner return get(BB->getParent(), BB); 13552ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner} 13562ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 13572ee11eccdde14c95c78773be76b02bb5fd09d7eeChris LattnerBlockAddress *BlockAddress::get(Function *F, BasicBlock *BB) { 13582ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner BlockAddress *&BA = 13592ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner F->getContext().pImpl->BlockAddresses[std::make_pair(F, BB)]; 13602ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner if (BA == 0) 13612ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner BA = new BlockAddress(F, BB); 1362a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 13632ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner assert(BA->getFunction() == F && "Basic block moved between functions"); 13642ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner return BA; 13652ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner} 13662ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 13672ee11eccdde14c95c78773be76b02bb5fd09d7eeChris LattnerBlockAddress::BlockAddress(Function *F, BasicBlock *BB) 13682ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner: Constant(Type::getInt8PtrTy(F->getContext()), Value::BlockAddressVal, 13692ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner &Op<0>(), 2) { 1370d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner setOperand(0, F); 1371d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner setOperand(1, BB); 1372cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner BB->AdjustBlockAddressRefCount(1); 13732ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner} 13742ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 13752ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 13762ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner// destroyConstant - Remove the constant from the constant table. 13772ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner// 13782ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattnervoid BlockAddress::destroyConstant() { 13791afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner getFunction()->getType()->getContext().pImpl 13802ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner ->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock())); 1381cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner getBasicBlock()->AdjustBlockAddressRefCount(-1); 13822ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner destroyConstantImpl(); 13832ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner} 13842ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 13852ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattnervoid BlockAddress::replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) { 13862ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // This could be replacing either the Basic Block or the Function. In either 13872ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // case, we have to remove the map entry. 13882ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner Function *NewF = getFunction(); 13892ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner BasicBlock *NewBB = getBasicBlock(); 1390a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 13912ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner if (U == &Op<0>()) 1392c06e5cf2e3724762a6c9830a00395736ec07d81aDerek Schuff NewF = cast<Function>(To->stripPointerCasts()); 13932ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner else 13942ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner NewBB = cast<BasicBlock>(To); 1395a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 13962ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // See if the 'new' entry already exists, if not, just update this in place 13972ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // and return early. 13982ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner BlockAddress *&NewBA = 13992ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner getContext().pImpl->BlockAddresses[std::make_pair(NewF, NewBB)]; 14002ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner if (NewBA == 0) { 1401d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner getBasicBlock()->AdjustBlockAddressRefCount(-1); 1402a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 14032ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // Remove the old entry, this can't cause the map to rehash (just a 14042ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // tombstone will get added). 14052ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner getContext().pImpl->BlockAddresses.erase(std::make_pair(getFunction(), 14062ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner getBasicBlock())); 14072ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner NewBA = this; 1408d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner setOperand(0, NewF); 1409d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner setOperand(1, NewBB); 1410d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner getBasicBlock()->AdjustBlockAddressRefCount(1); 14112ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner return; 14122ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner } 14132ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 14142ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // Otherwise, I do need to replace this with an existing value. 14152ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner assert(NewBA != this && "I didn't contain From!"); 1416a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 14172ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // Everyone using this now uses the replacement. 1418678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner replaceAllUsesWith(NewBA); 1419a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 14202ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner destroyConstant(); 14212ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner} 14222ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 14232ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner//---- ConstantExpr::get() implementations. 1424345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve// 142579e21d338c60b4b5a5746fc45e37ea0310606aeeReid Spencer 14263da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer/// This is a utility function to handle folding of casts and lookup of the 142766a1a05c86721b2769ef107d39675afe3c79b913Duncan Sands/// cast in the ExprConstants map. It is used by the various get* methods below. 14283da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencerstatic inline Constant *getFoldedCast( 1429db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Instruction::CastOps opc, Constant *C, Type *Ty) { 14309eacf8aac8fa19ec5f3e849747af860b023e4dc4Chris Lattner assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!"); 14313da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Fold a few common cases 1432b29d596072d2ba32a0bb59241baf7a1c0ff5ed94Chris Lattner if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty)) 14333da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer return FC; 1434d628f6a9a47dcb157db01a0568772fed1efcfe90Chris Lattner 1435d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson LLVMContextImpl *pImpl = Ty->getContext().pImpl; 1436d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 143782e905aae4fe815fc57f50663467cb03e4c9e9e1Nadav Rotem // Look up the constant in the table first to ensure uniqueness. 143855d8f6d49023de5182efbb29d0b3bd0035909d62Nadav Rotem ExprMapKeyType Key(opc, C); 1439a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1440d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return pImpl->ExprConstants.getOrCreate(Ty, Key); 1441345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve} 1442a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1443db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getCast(unsigned oc, Constant *C, Type *Ty) { 14443da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Instruction::CastOps opc = Instruction::CastOps(oc); 14453da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer assert(Instruction::isCast(opc) && "opcode out of range"); 14463da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer assert(C && Ty && "Null arguments to getCast"); 14470b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!"); 14483da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 14493da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer switch (opc) { 14500b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner default: 14510b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner llvm_unreachable("Invalid cast opcode"); 14520b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::Trunc: return getTrunc(C, Ty); 14530b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::ZExt: return getZExt(C, Ty); 14540b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::SExt: return getSExt(C, Ty); 14550b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::FPTrunc: return getFPTrunc(C, Ty); 14560b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::FPExt: return getFPExtend(C, Ty); 14570b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::UIToFP: return getUIToFP(C, Ty); 14580b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::SIToFP: return getSIToFP(C, Ty); 14590b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::FPToUI: return getFPToUI(C, Ty); 14600b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::FPToSI: return getFPToSI(C, Ty); 14610b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::PtrToInt: return getPtrToInt(C, Ty); 14620b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::IntToPtr: return getIntToPtr(C, Ty); 14630b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::BitCast: return getBitCast(C, Ty); 1464f5ac6c27acd65ae2c9eafd355b781123d9882087Chris Lattner } 1465a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova} 14667858b336f23405a96ee25de1b9071aeaf270bd77Reid Spencer 1467db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getZExtOrBitCast(Constant *C, Type *Ty) { 14686de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 14693b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getBitCast(C, Ty); 14703b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getZExt(C, Ty); 1471848414e49c7600e3002a4366de52d03a9638b327Reid Spencer} 1472848414e49c7600e3002a4366de52d03a9638b327Reid Spencer 1473db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getSExtOrBitCast(Constant *C, Type *Ty) { 14746de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 14753b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getBitCast(C, Ty); 14763b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getSExt(C, Ty); 1477848414e49c7600e3002a4366de52d03a9638b327Reid Spencer} 1478848414e49c7600e3002a4366de52d03a9638b327Reid Spencer 1479db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getTruncOrBitCast(Constant *C, Type *Ty) { 14806de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 14813b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getBitCast(C, Ty); 14823b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getTrunc(C, Ty); 1483848414e49c7600e3002a4366de52d03a9638b327Reid Spencer} 1484848414e49c7600e3002a4366de52d03a9638b327Reid Spencer 1485db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getPointerCast(Constant *S, Type *Ty) { 1486655578f8b5275e7c59b87d4709b0d56b2621caacEvgeniy Stepanov assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); 1487655578f8b5275e7c59b87d4709b0d56b2621caacEvgeniy Stepanov assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) && 1488655578f8b5275e7c59b87d4709b0d56b2621caacEvgeniy Stepanov "Invalid cast"); 1489c0459fb7f52ca1bcba977f3e72abc050af078aeeReid Spencer 1490655578f8b5275e7c59b87d4709b0d56b2621caacEvgeniy Stepanov if (Ty->isIntOrIntVectorTy()) 14913b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getPtrToInt(S, Ty); 14923b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getBitCast(S, Ty); 1493c0459fb7f52ca1bcba977f3e72abc050af078aeeReid Spencer} 1494c0459fb7f52ca1bcba977f3e72abc050af078aeeReid Spencer 1495db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getIntegerCast(Constant *C, Type *Ty, 149684f3eab017d56b6854155f2350759dc77ac48aadReid Spencer bool isSigned) { 1497b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && 1498b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands Ty->isIntOrIntVectorTy() && "Invalid cast"); 14996de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman unsigned SrcBits = C->getType()->getScalarSizeInBits(); 15006de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman unsigned DstBits = Ty->getScalarSizeInBits(); 150184f3eab017d56b6854155f2350759dc77ac48aadReid Spencer Instruction::CastOps opcode = 150284f3eab017d56b6854155f2350759dc77ac48aadReid Spencer (SrcBits == DstBits ? Instruction::BitCast : 150384f3eab017d56b6854155f2350759dc77ac48aadReid Spencer (SrcBits > DstBits ? Instruction::Trunc : 150484f3eab017d56b6854155f2350759dc77ac48aadReid Spencer (isSigned ? Instruction::SExt : Instruction::ZExt))); 150584f3eab017d56b6854155f2350759dc77ac48aadReid Spencer return getCast(opcode, C, Ty); 150684f3eab017d56b6854155f2350759dc77ac48aadReid Spencer} 150784f3eab017d56b6854155f2350759dc77ac48aadReid Spencer 1508db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getFPCast(Constant *C, Type *Ty) { 1509b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && 151084f3eab017d56b6854155f2350759dc77ac48aadReid Spencer "Invalid cast"); 15116de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman unsigned SrcBits = C->getType()->getScalarSizeInBits(); 15126de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman unsigned DstBits = Ty->getScalarSizeInBits(); 1513f25212a223b649bf602d3a0489254139cd2c07e4Reid Spencer if (SrcBits == DstBits) 1514f25212a223b649bf602d3a0489254139cd2c07e4Reid Spencer return C; // Avoid a useless cast 151584f3eab017d56b6854155f2350759dc77ac48aadReid Spencer Instruction::CastOps opcode = 15169afc527671618e6cd878c29f5a3ac63598486994Jay Foad (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt); 151784f3eab017d56b6854155f2350759dc77ac48aadReid Spencer return getCast(opcode, C, Ty); 151884f3eab017d56b6854155f2350759dc77ac48aadReid Spencer} 151984f3eab017d56b6854155f2350759dc77ac48aadReid Spencer 1520db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getTrunc(Constant *C, Type *Ty) { 15216de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#ifndef NDEBUG 15226de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 15236de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool toVec = Ty->getTypeID() == Type::VectorTyID; 15246de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#endif 15256de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1526b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && "Trunc operand must be integer"); 1527b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral"); 15286de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&& 15293da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "SrcTy must be larger than DestTy for Trunc!"); 15303da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 153104fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::Trunc, C, Ty); 15323da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15333da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1534db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getSExt(Constant *C, Type *Ty) { 15356de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#ifndef NDEBUG 15366de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 15376de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool toVec = Ty->getTypeID() == Type::VectorTyID; 15386de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#endif 15396de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1540b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && "SExt operand must be integral"); 1541b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(Ty->isIntOrIntVectorTy() && "SExt produces only integer"); 15426de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&& 15433da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "SrcTy must be smaller than DestTy for SExt!"); 15443da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 154504fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::SExt, C, Ty); 1546d144f42a5aa0e9c41b0bf478ea20742c09e9a015Chris Lattner} 1547d144f42a5aa0e9c41b0bf478ea20742c09e9a015Chris Lattner 1548db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getZExt(Constant *C, Type *Ty) { 15496de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#ifndef NDEBUG 15506de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 15516de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool toVec = Ty->getTypeID() == Type::VectorTyID; 15526de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#endif 15536de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1554b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && "ZEXt operand must be integral"); 1555b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(Ty->isIntOrIntVectorTy() && "ZExt produces only integer"); 15566de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&& 15573da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "SrcTy must be smaller than DestTy for ZExt!"); 15583da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 155904fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::ZExt, C, Ty); 15603da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15613da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1562db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getFPTrunc(Constant *C, Type *Ty) { 15636de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#ifndef NDEBUG 15646de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 15656de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool toVec = Ty->getTypeID() == Type::VectorTyID; 15666de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#endif 15676de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1568b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && 15696de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&& 15703da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "This is an illegal floating point truncation!"); 157104fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::FPTrunc, C, Ty); 15723da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15733da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1574db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getFPExtend(Constant *C, Type *Ty) { 15756de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#ifndef NDEBUG 15766de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 15776de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool toVec = Ty->getTypeID() == Type::VectorTyID; 15786de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#endif 15796de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1580b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && 15816de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&& 15823da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "This is an illegal floating point extension!"); 158304fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::FPExt, C, Ty); 15843da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15853da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1586db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getUIToFP(Constant *C, Type *Ty) { 1587b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#ifndef NDEBUG 1588b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 1589b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool toVec = Ty->getTypeID() == Type::VectorTyID; 1590b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#endif 1591b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1592b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() && 1593b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman "This is an illegal uint to floating point cast!"); 159404fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::UIToFP, C, Ty); 15953da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 15963da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1597db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getSIToFP(Constant *C, Type *Ty) { 1598b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#ifndef NDEBUG 1599b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 1600b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool toVec = Ty->getTypeID() == Type::VectorTyID; 1601b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#endif 1602b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1603b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() && 16043da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "This is an illegal sint to floating point cast!"); 160504fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::SIToFP, C, Ty); 16063da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16073da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1608db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getFPToUI(Constant *C, Type *Ty) { 1609b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#ifndef NDEBUG 1610b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 1611b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool toVec = Ty->getTypeID() == Type::VectorTyID; 1612b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#endif 1613b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1614b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() && 1615b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman "This is an illegal floating point to uint cast!"); 161604fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::FPToUI, C, Ty); 16173da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16183da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1619db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getFPToSI(Constant *C, Type *Ty) { 1620b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#ifndef NDEBUG 1621b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 1622b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool toVec = Ty->getTypeID() == Type::VectorTyID; 1623b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#endif 1624b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1625b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() && 1626b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman "This is an illegal floating point to sint cast!"); 162704fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::FPToSI, C, Ty); 16283da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16293da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1630db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getPtrToInt(Constant *C, Type *DstTy) { 16311608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem assert(C->getType()->getScalarType()->isPointerTy() && 16321608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem "PtrToInt source must be pointer or pointer vector"); 16331608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem assert(DstTy->getScalarType()->isIntegerTy() && 16341608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem "PtrToInt destination must be integer or integer vector"); 1635af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy)); 16361486ae626f1af5c2797f4d13e9c57b3a0e473811Nick Lewycky if (isa<VectorType>(C->getType())) 1637230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner assert(C->getType()->getVectorNumElements()==DstTy->getVectorNumElements()&& 1638af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner "Invalid cast between a different number of vector elements"); 163904fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::PtrToInt, C, DstTy); 16403da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16413da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1642db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getIntToPtr(Constant *C, Type *DstTy) { 16431608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem assert(C->getType()->getScalarType()->isIntegerTy() && 16441608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem "IntToPtr source must be integer or integer vector"); 16451608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem assert(DstTy->getScalarType()->isPointerTy() && 16461608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem "IntToPtr destination must be a pointer or pointer vector"); 1647af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy)); 16481486ae626f1af5c2797f4d13e9c57b3a0e473811Nick Lewycky if (isa<VectorType>(C->getType())) 1649230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner assert(C->getType()->getVectorNumElements()==DstTy->getVectorNumElements()&& 1650af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner "Invalid cast between a different number of vector elements"); 165104fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::IntToPtr, C, DstTy); 16523da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16533da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1654db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getBitCast(Constant *C, Type *DstTy) { 16550b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner assert(CastInst::castIsValid(Instruction::BitCast, C, DstTy) && 16560b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner "Invalid constantexpr bitcast!"); 1657a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 16588c7f24a36ad7d5aa7322a64d22666fec35fb8478Chris Lattner // It is common to ask for a bitcast of a value to its own type, handle this 16598c7f24a36ad7d5aa7322a64d22666fec35fb8478Chris Lattner // speedily. 16608c7f24a36ad7d5aa7322a64d22666fec35fb8478Chris Lattner if (C->getType() == DstTy) return C; 1661a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 166204fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::BitCast, C, DstTy); 1663d144f42a5aa0e9c41b0bf478ea20742c09e9a015Chris Lattner} 1664d144f42a5aa0e9c41b0bf478ea20742c09e9a015Chris Lattner 1665eaf79809e8a78bf407bb26b9d7c59f32c142188aChris LattnerConstant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2, 1666eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner unsigned Flags) { 1667eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner // Check the operands for consistency first. 16680a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer assert(Opcode >= Instruction::BinaryOpsBegin && 16690a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer Opcode < Instruction::BinaryOpsEnd && 1670f31f583b153dacac9f91d6109cdfad140ad0cec1Chris Lattner "Invalid opcode in binary constant expression"); 1671f31f583b153dacac9f91d6109cdfad140ad0cec1Chris Lattner assert(C1->getType() == C2->getType() && 1672f31f583b153dacac9f91d6109cdfad140ad0cec1Chris Lattner "Operand types in binary constant expression should match"); 1673a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 167491b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner#ifndef NDEBUG 167591b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner switch (Opcode) { 1676ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: 16770a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::Sub: 1678ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: 1679ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1680b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isIntOrIntVectorTy() && 1681ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman "Tried to create an integer operation on a non-integer type!"); 1682ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman break; 1683ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 1684ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 1685ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 168691b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1687b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isFPOrFPVectorTy() && 1688ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman "Tried to create a floating-point operation on a " 1689ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman "non-floating-point type!"); 169091b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner break; 16911628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::UDiv: 16921628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::SDiv: 16931628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1694b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isIntOrIntVectorTy() && 16951628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer "Tried to create an arithmetic operation on a non-arithmetic type!"); 16961628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer break; 16971628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::FDiv: 16981628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1699b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isFPOrFPVectorTy() && 1700f57478f381e77e3afd8139fabe7faed991b40d69Dan Gohman "Tried to create an arithmetic operation on a non-arithmetic type!"); 17011628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer break; 17020a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::URem: 17030a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::SRem: 17040a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1705b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isIntOrIntVectorTy() && 17060a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer "Tried to create an arithmetic operation on a non-arithmetic type!"); 17070a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer break; 17080a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::FRem: 17090a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1710b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isFPOrFPVectorTy() && 1711f57478f381e77e3afd8139fabe7faed991b40d69Dan Gohman "Tried to create an arithmetic operation on a non-arithmetic type!"); 17120a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer break; 171391b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner case Instruction::And: 171491b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner case Instruction::Or: 171591b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner case Instruction::Xor: 171691b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1717b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isIntOrIntVectorTy() && 17181bae291cb9cafc8a8c86538449b78a575ed9834aMisha Brukman "Tried to create a logical operation on a non-integral type!"); 171991b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner break; 172091b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner case Instruction::Shl: 17213822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer case Instruction::LShr: 17223822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer case Instruction::AShr: 1723832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1724b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isIntOrIntVectorTy() && 172591b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner "Tried to create a shift operation on a non-integer type!"); 172691b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner break; 172791b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner default: 172891b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner break; 172991b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner } 173091b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner#endif 173191b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner 1732eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2)) 1733eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return FC; // Fold a few common cases. 1734a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 17354e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { C1, C2 }; 17364e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer ExprMapKeyType Key(Opcode, ArgVec, 0, Flags); 1737a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1738eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = C1->getContext().pImpl; 1739eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return pImpl->ExprConstants.getOrCreate(C1->getType(), Key); 174067263fec757aa7b8a3c7efe1290dc5415aa59c35Reid Spencer} 174167263fec757aa7b8a3c7efe1290dc5415aa59c35Reid Spencer 1742db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getSizeOf(Type* Ty) { 1743baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson // sizeof is implemented as: (i64) gep (Ty*)null, 1 1744baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson // Note that a non-inbounds gep is used, as null isn't within any object. 17451d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1); 1746baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *GEP = getGetElementPtr( 1747dab3d29605a5c83db41b28176273ef55961120c1Jay Foad Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx); 17483b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getPtrToInt(GEP, 17493b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman Type::getInt64Ty(Ty->getContext())); 1750baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 1751baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 1752db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getAlignOf(Type* Ty) { 17530f5efe56258f8cd6ceff4d7955a5d80144cd9cb0Dan Gohman // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1 1754e2574d3215c412a15763d26aee9aa5d856764c2cDan Gohman // Note that a non-inbounds gep is used, as null isn't within any object. 1755db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AligningTy = 1756b2318662b6d2e6d9ea9917fd280dde0ba9a938adChris Lattner StructType::get(Type::getInt1Ty(Ty->getContext()), Ty, NULL); 1757b8bce928f4ffdf50eff69334f3e25b27848536b6Micah Villmow Constant *NullPtr = Constant::getNullValue(AligningTy->getPointerTo()); 175806ed3e788ab3d71350b7cc7d077f4bd9a2b57799Dan Gohman Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0); 17591d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1); 1760baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *Indices[2] = { Zero, One }; 1761dab3d29605a5c83db41b28176273ef55961120c1Jay Foad Constant *GEP = getGetElementPtr(NullPtr, Indices); 17623b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getPtrToInt(GEP, 17633b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman Type::getInt64Ty(Ty->getContext())); 1764baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 1765baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 1766db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getOffsetOf(StructType* STy, unsigned FieldNo) { 17672544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman return getOffsetOf(STy, ConstantInt::get(Type::getInt32Ty(STy->getContext()), 17682544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman FieldNo)); 17692544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman} 17702544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman 1771db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getOffsetOf(Type* Ty, Constant *FieldNo) { 17723778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman // offsetof is implemented as: (i64) gep (Ty*)null, 0, FieldNo 17733778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman // Note that a non-inbounds gep is used, as null isn't within any object. 17743778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman Constant *GEPIdx[] = { 17752544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0), 17762544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman FieldNo 17773778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman }; 17783778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman Constant *GEP = getGetElementPtr( 1779dab3d29605a5c83db41b28176273ef55961120c1Jay Foad Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx); 17803b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getPtrToInt(GEP, 17813b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman Type::getInt64Ty(Ty->getContext())); 17823778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman} 1783baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 1784eaf79809e8a78bf407bb26b9d7c59f32c142188aChris LattnerConstant *ConstantExpr::getCompare(unsigned short Predicate, 1785eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner Constant *C1, Constant *C2) { 178667263fec757aa7b8a3c7efe1290dc5415aa59c35Reid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1787a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1788eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner switch (Predicate) { 1789eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner default: llvm_unreachable("Invalid CmpInst predicate"); 1790eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_FALSE: case CmpInst::FCMP_OEQ: case CmpInst::FCMP_OGT: 1791eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_OGE: case CmpInst::FCMP_OLT: case CmpInst::FCMP_OLE: 1792eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_ONE: case CmpInst::FCMP_ORD: case CmpInst::FCMP_UNO: 1793eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_UEQ: case CmpInst::FCMP_UGT: case CmpInst::FCMP_UGE: 1794eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_ULT: case CmpInst::FCMP_ULE: case CmpInst::FCMP_UNE: 1795eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_TRUE: 1796eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return getFCmp(Predicate, C1, C2); 1797a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1798eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::ICMP_EQ: case CmpInst::ICMP_NE: case CmpInst::ICMP_UGT: 1799eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::ICMP_UGE: case CmpInst::ICMP_ULT: case CmpInst::ICMP_ULE: 1800eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::ICMP_SGT: case CmpInst::ICMP_SGE: case CmpInst::ICMP_SLT: 1801eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::ICMP_SLE: 1802eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return getICmp(Predicate, C1, C2); 1803eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner } 1804c3d12f082397ec069cad1466967cef37c2fef185Chris Lattner} 1805c3d12f082397ec069cad1466967cef37c2fef185Chris Lattner 1806eaf79809e8a78bf407bb26b9d7c59f32c142188aChris LattnerConstant *ConstantExpr::getSelect(Constant *C, Constant *V1, Constant *V2) { 18079ace0cdb12be5e9c213567209ace721dfeccaddfChris Lattner assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands"); 180808a45cc2ffc7698ee1f74b71afd9d4fb8e49daf8Chris Lattner 1809eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2)) 1810eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return SC; // Fold common cases 181108a45cc2ffc7698ee1f74b71afd9d4fb8e49daf8Chris Lattner 18124e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { C, V1, V2 }; 18134e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer ExprMapKeyType Key(Instruction::Select, ArgVec); 1814a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1815eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = C->getContext().pImpl; 1816eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return pImpl->ExprConstants.getOrCreate(V1->getType(), Key); 181708a45cc2ffc7698ee1f74b71afd9d4fb8e49daf8Chris Lattner} 181808a45cc2ffc7698ee1f74b71afd9d4fb8e49daf8Chris Lattner 1819dab3d29605a5c83db41b28176273ef55961120c1Jay FoadConstant *ConstantExpr::getGetElementPtr(Constant *C, ArrayRef<Value *> Idxs, 1820dab3d29605a5c83db41b28176273ef55961120c1Jay Foad bool InBounds) { 18212333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert(C->getType()->isPtrOrPtrVectorTy() && 18222333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands "Non-pointer type for constant GetElementPtr expression"); 18232333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands 1824dab3d29605a5c83db41b28176273ef55961120c1Jay Foad if (Constant *FC = ConstantFoldGetElementPtr(C, InBounds, Idxs)) 18251f78d51be69964b38c5fc76ceb2147b737d09857Chris Lattner return FC; // Fold a few common cases. 1826f8dbee7cea072eb63ae343759975109553697bcbDan Gohman 1827eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner // Get the result type of the getelementptr! 1828a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), Idxs); 1829eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner assert(Ty && "GEP indices invalid!"); 1830230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner unsigned AS = C->getType()->getPointerAddressSpace(); 1831eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner Type *ReqTy = Ty->getPointerTo(AS); 18322333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands if (VectorType *VecTy = dyn_cast<VectorType>(C->getType())) 18332333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands ReqTy = VectorType::get(ReqTy, VecTy->getNumElements()); 1834a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1835f8dbee7cea072eb63ae343759975109553697bcbDan Gohman // Look up the constant in the table first to ensure uniqueness 1836f8dbee7cea072eb63ae343759975109553697bcbDan Gohman std::vector<Constant*> ArgVec; 1837dab3d29605a5c83db41b28176273ef55961120c1Jay Foad ArgVec.reserve(1 + Idxs.size()); 1838f8dbee7cea072eb63ae343759975109553697bcbDan Gohman ArgVec.push_back(C); 18392333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands for (unsigned i = 0, e = Idxs.size(); i != e; ++i) { 18402333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert(Idxs[i]->getType()->isVectorTy() == ReqTy->isVectorTy() && 18412333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands "getelementptr index type missmatch"); 18422333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert((!Idxs[i]->getType()->isVectorTy() || 18432333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands ReqTy->getVectorNumElements() == 18442333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands Idxs[i]->getType()->getVectorNumElements()) && 18452333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands "getelementptr index type missmatch"); 1846f8dbee7cea072eb63ae343759975109553697bcbDan Gohman ArgVec.push_back(cast<Constant>(Idxs[i])); 18472333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands } 1848f8dbee7cea072eb63ae343759975109553697bcbDan Gohman const ExprMapKeyType Key(Instruction::GetElementPtr, ArgVec, 0, 18491f78d51be69964b38c5fc76ceb2147b737d09857Chris Lattner InBounds ? GEPOperator::IsInBounds : 0); 1850a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1851eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = C->getContext().pImpl; 1852f8dbee7cea072eb63ae343759975109553697bcbDan Gohman return pImpl->ExprConstants.getOrCreate(ReqTy, Key); 1853f8dbee7cea072eb63ae343759975109553697bcbDan Gohman} 1854f8dbee7cea072eb63ae343759975109553697bcbDan Gohman 1855077d0eb1bd54b71143139a5184d291454d638ebcReid SpencerConstant * 1856401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick LewyckyConstantExpr::getICmp(unsigned short pred, Constant *LHS, Constant *RHS) { 1857077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer assert(LHS->getType() == RHS->getType()); 1858077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE && 1859077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate"); 1860077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1861b29d596072d2ba32a0bb59241baf7a1c0ff5ed94Chris Lattner if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS)) 1862077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer return FC; // Fold a few common cases... 1863077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1864077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer // Look up the constant in the table first to ensure uniqueness 18654e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { LHS, RHS }; 18664fa021a1a9e062683e203d775bae897fb8b75facReid Spencer // Get the key type with both the opcode and predicate 1867077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer const ExprMapKeyType Key(Instruction::ICmp, ArgVec, pred); 186831c36f02f26def914727a521e7ca5fad450920caOwen Anderson 1869db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ResultTy = Type::getInt1Ty(LHS->getContext()); 1870db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VT = dyn_cast<VectorType>(LHS->getType())) 1871401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky ResultTy = VectorType::get(ResultTy, VT->getNumElements()); 1872401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky 1873d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl; 1874401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky return pImpl->ExprConstants.getOrCreate(ResultTy, Key); 1875077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer} 1876077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1877077d0eb1bd54b71143139a5184d291454d638ebcReid SpencerConstant * 1878401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick LewyckyConstantExpr::getFCmp(unsigned short pred, Constant *LHS, Constant *RHS) { 1879077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer assert(LHS->getType() == RHS->getType()); 1880077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate"); 1881077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1882b29d596072d2ba32a0bb59241baf7a1c0ff5ed94Chris Lattner if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS)) 1883077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer return FC; // Fold a few common cases... 1884077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1885077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer // Look up the constant in the table first to ensure uniqueness 18864e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { LHS, RHS }; 18874fa021a1a9e062683e203d775bae897fb8b75facReid Spencer // Get the key type with both the opcode and predicate 1888077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer const ExprMapKeyType Key(Instruction::FCmp, ArgVec, pred); 1889401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky 1890db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ResultTy = Type::getInt1Ty(LHS->getContext()); 1891db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VT = dyn_cast<VectorType>(LHS->getType())) 1892401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky ResultTy = VectorType::get(ResultTy, VT->getNumElements()); 1893401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky 1894d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl; 1895401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky return pImpl->ExprConstants.getOrCreate(ResultTy, Key); 1896077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer} 1897077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1898b52ee7f5ffd189c4f21ab227c6a24061ef3378fcRobert BocchinoConstant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) { 18991df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(Val->getType()->isVectorTy() && 1900ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer "Tried to create extractelement operation on non-vector type!"); 1901b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(Idx->getType()->isIntegerTy(32) && 19023d10b0b2d35be0c99fe95c6d0c4931916c8a59cfReid Spencer "Extractelement index must be i32 type!"); 1903a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1904eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner if (Constant *FC = ConstantFoldExtractElementInstruction(Val, Idx)) 190583738a20ddb64838f94461320c6af8ae2a8329baChris Lattner return FC; // Fold a few common cases. 1906a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1907c152f9cd26e7cb32352c513389a18ffd892ecaecRobert Bocchino // Look up the constant in the table first to ensure uniqueness 19084e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { Val, Idx }; 19094e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer const ExprMapKeyType Key(Instruction::ExtractElement, ArgVec); 1910a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1911eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = Val->getContext().pImpl; 1912230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner Type *ReqTy = Val->getType()->getVectorElementType(); 1913d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return pImpl->ExprConstants.getOrCreate(ReqTy, Key); 1914c152f9cd26e7cb32352c513389a18ffd892ecaecRobert Bocchino} 1915c152f9cd26e7cb32352c513389a18ffd892ecaecRobert Bocchino 1916c152f9cd26e7cb32352c513389a18ffd892ecaecRobert BocchinoConstant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt, 1917c152f9cd26e7cb32352c513389a18ffd892ecaecRobert Bocchino Constant *Idx) { 19181df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(Val->getType()->isVectorTy() && 1919ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer "Tried to create insertelement operation on non-vector type!"); 1920230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner assert(Elt->getType() == Val->getType()->getVectorElementType() && 1921230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner "Insertelement types must match!"); 1922b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(Idx->getType()->isIntegerTy(32) && 19233d10b0b2d35be0c99fe95c6d0c4931916c8a59cfReid Spencer "Insertelement index must be i32 type!"); 1924c152f9cd26e7cb32352c513389a18ffd892ecaecRobert Bocchino 1925eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx)) 1926eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return FC; // Fold a few common cases. 192700f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner // Look up the constant in the table first to ensure uniqueness 19284e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { Val, Elt, Idx }; 19294e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer const ExprMapKeyType Key(Instruction::InsertElement, ArgVec); 1930a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1931eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = Val->getContext().pImpl; 1932eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return pImpl->ExprConstants.getOrCreate(Val->getType(), Key); 193300f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner} 193400f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner 193500f1023cf8b30c74dc219525f518a80c45b6e7baChris LattnerConstant *ConstantExpr::getShuffleVector(Constant *V1, Constant *V2, 193600f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner Constant *Mask) { 193700f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner assert(ShuffleVectorInst::isValidOperands(V1, V2, Mask) && 193800f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner "Invalid shuffle vector constant expr operands!"); 19390f123cf732ad249117b7471e37bf819633b76a6eNate Begeman 1940eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask)) 1941eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return FC; // Fold a few common cases. 1942eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner 1943230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner unsigned NElts = Mask->getType()->getVectorNumElements(); 1944230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner Type *EltTy = V1->getType()->getVectorElementType(); 1945db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ShufTy = VectorType::get(EltTy, NElts); 194600f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner 1947eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner // Look up the constant in the table first to ensure uniqueness 19484e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { V1, V2, Mask }; 19494e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer const ExprMapKeyType Key(Instruction::ShuffleVector, ArgVec); 1950a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1951eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = ShufTy->getContext().pImpl; 1952eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return pImpl->ExprConstants.getOrCreate(ShufTy, Key); 1953041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman} 1954041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman 1955041e2eb51721bcfecee5d9c9fc409ff185526e47Dan GohmanConstant *ConstantExpr::getInsertValue(Constant *Agg, Constant *Val, 1956fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad ArrayRef<unsigned> Idxs) { 195710050d19e857396e65289c05ce9714e0a570deedHal Finkel assert(Agg->getType()->isFirstClassType() && 195810050d19e857396e65289c05ce9714e0a570deedHal Finkel "Non-first-class type for constant insertvalue expression"); 195910050d19e857396e65289c05ce9714e0a570deedHal Finkel 1960fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad assert(ExtractValueInst::getIndexedType(Agg->getType(), 1961fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad Idxs) == Val->getType() && 1962eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner "insertvalue indices invalid!"); 196310050d19e857396e65289c05ce9714e0a570deedHal Finkel Type *ReqTy = Val->getType(); 196410050d19e857396e65289c05ce9714e0a570deedHal Finkel 196510050d19e857396e65289c05ce9714e0a570deedHal Finkel if (Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs)) 196610050d19e857396e65289c05ce9714e0a570deedHal Finkel return FC; 196710050d19e857396e65289c05ce9714e0a570deedHal Finkel 196810050d19e857396e65289c05ce9714e0a570deedHal Finkel Constant *ArgVec[] = { Agg, Val }; 196910050d19e857396e65289c05ce9714e0a570deedHal Finkel const ExprMapKeyType Key(Instruction::InsertValue, ArgVec, 0, 0, Idxs); 197010050d19e857396e65289c05ce9714e0a570deedHal Finkel 197110050d19e857396e65289c05ce9714e0a570deedHal Finkel LLVMContextImpl *pImpl = Agg->getContext().pImpl; 197210050d19e857396e65289c05ce9714e0a570deedHal Finkel return pImpl->ExprConstants.getOrCreate(ReqTy, Key); 1973041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman} 1974041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman 1975041e2eb51721bcfecee5d9c9fc409ff185526e47Dan GohmanConstant *ConstantExpr::getExtractValue(Constant *Agg, 1976fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad ArrayRef<unsigned> Idxs) { 1977e4569943d936d73dec6f36f545e9902095bd3fd8Dan Gohman assert(Agg->getType()->isFirstClassType() && 1978e4569943d936d73dec6f36f545e9902095bd3fd8Dan Gohman "Tried to create extractelement operation on non-first-class type!"); 1979041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman 1980db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ReqTy = ExtractValueInst::getIndexedType(Agg->getType(), Idxs); 1981dc770fcb2c84068a64b471fe6c4c56966cf3021fChandler Carruth (void)ReqTy; 1982041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman assert(ReqTy && "extractvalue indices invalid!"); 1983a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1984eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner assert(Agg->getType()->isFirstClassType() && 1985eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner "Non-first-class type for constant extractvalue expression"); 198610050d19e857396e65289c05ce9714e0a570deedHal Finkel if (Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs)) 198710050d19e857396e65289c05ce9714e0a570deedHal Finkel return FC; 198810050d19e857396e65289c05ce9714e0a570deedHal Finkel 198910050d19e857396e65289c05ce9714e0a570deedHal Finkel Constant *ArgVec[] = { Agg }; 199010050d19e857396e65289c05ce9714e0a570deedHal Finkel const ExprMapKeyType Key(Instruction::ExtractValue, ArgVec, 0, 0, Idxs); 199110050d19e857396e65289c05ce9714e0a570deedHal Finkel 199210050d19e857396e65289c05ce9714e0a570deedHal Finkel LLVMContextImpl *pImpl = Agg->getContext().pImpl; 199310050d19e857396e65289c05ce9714e0a570deedHal Finkel return pImpl->ExprConstants.getOrCreate(ReqTy, Key); 1994041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman} 1995041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman 199681baf14fdfa29c22a08d609144c285169e23a247Chris LattnerConstant *ConstantExpr::getNeg(Constant *C, bool HasNUW, bool HasNSW) { 1997b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && 1998baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson "Cannot NEG a nonintegral value!"); 199981baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return getSub(ConstantFP::getZeroValueForNegation(C->getType()), 200081baf14fdfa29c22a08d609144c285169e23a247Chris Lattner C, HasNUW, HasNSW); 2001baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2002baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2003f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFNeg(Constant *C) { 2004b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && 2005baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson "Cannot FNEG a non-floating-point value!"); 200681baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return getFSub(ConstantFP::getZeroValueForNegation(C->getType()), C); 2007baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2008baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2009f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getNot(Constant *C) { 2010b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && 2011baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson "Cannot NOT a nonintegral value!"); 2012a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return get(Instruction::Xor, C, Constant::getAllOnesValue(C->getType())); 2013baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2014baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 201581baf14fdfa29c22a08d609144c285169e23a247Chris LattnerConstant *ConstantExpr::getAdd(Constant *C1, Constant *C2, 201681baf14fdfa29c22a08d609144c285169e23a247Chris Lattner bool HasNUW, bool HasNSW) { 201781baf14fdfa29c22a08d609144c285169e23a247Chris Lattner unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | 201881baf14fdfa29c22a08d609144c285169e23a247Chris Lattner (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); 201981baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return get(Instruction::Add, C1, C2, Flags); 2020baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2021baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2022f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFAdd(Constant *C1, Constant *C2) { 2023baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::FAdd, C1, C2); 2024baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2025baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 202681baf14fdfa29c22a08d609144c285169e23a247Chris LattnerConstant *ConstantExpr::getSub(Constant *C1, Constant *C2, 202781baf14fdfa29c22a08d609144c285169e23a247Chris Lattner bool HasNUW, bool HasNSW) { 202881baf14fdfa29c22a08d609144c285169e23a247Chris Lattner unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | 202981baf14fdfa29c22a08d609144c285169e23a247Chris Lattner (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); 203081baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return get(Instruction::Sub, C1, C2, Flags); 2031baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2032baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2033f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFSub(Constant *C1, Constant *C2) { 2034baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::FSub, C1, C2); 2035baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2036baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 203781baf14fdfa29c22a08d609144c285169e23a247Chris LattnerConstant *ConstantExpr::getMul(Constant *C1, Constant *C2, 203881baf14fdfa29c22a08d609144c285169e23a247Chris Lattner bool HasNUW, bool HasNSW) { 203981baf14fdfa29c22a08d609144c285169e23a247Chris Lattner unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | 204081baf14fdfa29c22a08d609144c285169e23a247Chris Lattner (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); 204181baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return get(Instruction::Mul, C1, C2, Flags); 2042baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2043baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2044f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFMul(Constant *C1, Constant *C2) { 2045baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::FMul, C1, C2); 2046baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2047baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 204874f5c5abeafeaabefab470390ce0e7a36754c592Chris LattnerConstant *ConstantExpr::getUDiv(Constant *C1, Constant *C2, bool isExact) { 204974f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner return get(Instruction::UDiv, C1, C2, 205074f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner isExact ? PossiblyExactOperator::IsExact : 0); 2051baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2052baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 205374f5c5abeafeaabefab470390ce0e7a36754c592Chris LattnerConstant *ConstantExpr::getSDiv(Constant *C1, Constant *C2, bool isExact) { 205474f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner return get(Instruction::SDiv, C1, C2, 205574f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner isExact ? PossiblyExactOperator::IsExact : 0); 2056baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2057baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2058f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) { 2059baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::FDiv, C1, C2); 2060baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2061baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2062f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getURem(Constant *C1, Constant *C2) { 2063baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::URem, C1, C2); 2064baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2065baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2066f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getSRem(Constant *C1, Constant *C2) { 2067baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::SRem, C1, C2); 2068baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2069baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2070f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFRem(Constant *C1, Constant *C2) { 2071baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::FRem, C1, C2); 2072baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2073baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2074f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getAnd(Constant *C1, Constant *C2) { 2075baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::And, C1, C2); 2076baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2077baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2078f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getOr(Constant *C1, Constant *C2) { 2079baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::Or, C1, C2); 2080baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2081baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2082f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getXor(Constant *C1, Constant *C2) { 2083baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::Xor, C1, C2); 2084baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2085baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 208681baf14fdfa29c22a08d609144c285169e23a247Chris LattnerConstant *ConstantExpr::getShl(Constant *C1, Constant *C2, 208781baf14fdfa29c22a08d609144c285169e23a247Chris Lattner bool HasNUW, bool HasNSW) { 208881baf14fdfa29c22a08d609144c285169e23a247Chris Lattner unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | 208981baf14fdfa29c22a08d609144c285169e23a247Chris Lattner (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); 209081baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return get(Instruction::Shl, C1, C2, Flags); 2091baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2092baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 209374f5c5abeafeaabefab470390ce0e7a36754c592Chris LattnerConstant *ConstantExpr::getLShr(Constant *C1, Constant *C2, bool isExact) { 209474f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner return get(Instruction::LShr, C1, C2, 209574f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner isExact ? PossiblyExactOperator::IsExact : 0); 2096baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2097baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 209874f5c5abeafeaabefab470390ce0e7a36754c592Chris LattnerConstant *ConstantExpr::getAShr(Constant *C1, Constant *C2, bool isExact) { 209974f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner return get(Instruction::AShr, C1, C2, 210074f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner isExact ? PossiblyExactOperator::IsExact : 0); 2101baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2102baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2103c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// getBinOpIdentity - Return the identity for the given binary operation, 2104c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// i.e. a constant C such that X op C = X and C op X = X for every X. It 2105ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands/// returns null if the operator doesn't have an identity. 2106c038a7833565ecf92a699371d448135a097c9e2fDuncan SandsConstant *ConstantExpr::getBinOpIdentity(unsigned Opcode, Type *Ty) { 2107c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands switch (Opcode) { 2108c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands default: 2109ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands // Doesn't have an identity. 2110ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands return 0; 2111ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands 2112c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands case Instruction::Add: 2113c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands case Instruction::Or: 2114c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands case Instruction::Xor: 2115c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands return Constant::getNullValue(Ty); 2116c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands 2117c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands case Instruction::Mul: 2118c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands return ConstantInt::get(Ty, 1); 2119c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands 2120c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands case Instruction::And: 2121c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands return Constant::getAllOnesValue(Ty); 2122c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands } 2123c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands} 2124c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands 2125ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands/// getBinOpAbsorber - Return the absorbing element for the given binary 2126ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands/// operation, i.e. a constant C such that X op C = C and C op X = C for 2127ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands/// every X. For example, this returns zero for integer multiplication. 2128ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands/// It returns null if the operator doesn't have an absorbing element. 2129ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan SandsConstant *ConstantExpr::getBinOpAbsorber(unsigned Opcode, Type *Ty) { 2130ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands switch (Opcode) { 2131ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands default: 2132ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands // Doesn't have an absorber. 2133ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands return 0; 2134ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands 2135ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands case Instruction::Or: 2136ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands return Constant::getAllOnesValue(Ty); 2137ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands 2138ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands case Instruction::And: 2139ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands case Instruction::Mul: 2140ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands return Constant::getNullValue(Ty); 2141ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands } 2142ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands} 2143ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands 2144d0b1bb01f2847f53320fb1088100293e70405067Vikram S. Adve// destroyConstant - Remove the constant from the constant table... 2145d0b1bb01f2847f53320fb1088100293e70405067Vikram S. Adve// 214604fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantExpr::destroyConstant() { 21471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner getType()->getContext().pImpl->ExprConstants.remove(this); 2148d0b1bb01f2847f53320fb1088100293e70405067Vikram S. Adve destroyConstantImpl(); 2149345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve} 2150345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve 2151c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattnerconst char *ConstantExpr::getOpcodeName() const { 2152c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner return Instruction::getOpcodeName(getOpcode()); 2153345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve} 21541c9c8e64d22bcab91ce2321a06b2b5640a6ae927Reid Spencer 215504e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner 215604e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner 215704e3b1ef788cfac266896c6e89050c4ff60114e2Chris LattnerGetElementPtrConstantExpr:: 2158a7c698823e4ffa4589bde1ff6de60b6af0cdba5aChris LattnerGetElementPtrConstantExpr(Constant *C, ArrayRef<Constant*> IdxList, 2159db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DestTy) 216004e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner : ConstantExpr(DestTy, Instruction::GetElementPtr, 216104e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner OperandTraits<GetElementPtrConstantExpr>::op_end(this) 216204e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner - (IdxList.size()+1), IdxList.size()+1) { 216304e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner OperandList[0] = C; 216404e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner for (unsigned i = 0, E = IdxList.size(); i != E; ++i) 216504e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner OperandList[i+1] = IdxList[i]; 216604e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner} 216704e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner 216827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner//===----------------------------------------------------------------------===// 216927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner// ConstantData* implementations 217027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 217127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattnervoid ConstantDataArray::anchor() {} 217227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattnervoid ConstantDataVector::anchor() {} 217327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 217445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementType - Return the element type of the array/vector. 217545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris LattnerType *ConstantDataSequential::getElementType() const { 217645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return getType()->getElementType(); 217745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 217845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 21799e631da253bff90d9da5ace21bd73f1c838e72ebChris LattnerStringRef ConstantDataSequential::getRawDataValues() const { 21801ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner return StringRef(DataElements, getNumElements()*getElementByteSize()); 21819e631da253bff90d9da5ace21bd73f1c838e72ebChris Lattner} 21829e631da253bff90d9da5ace21bd73f1c838e72ebChris Lattner 2183ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// isElementTypeCompatible - Return true if a ConstantDataSequential can be 2184ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// formed with a vector or array of the specified element type. 2185ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// ConstantDataArray only works with normal float and int types that are 2186ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// stored densely in memory, not with things like i42 or x86_f80. 2187ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattnerbool ConstantDataSequential::isElementTypeCompatible(const Type *Ty) { 218845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner if (Ty->isFloatTy() || Ty->isDoubleTy()) return true; 218945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner if (const IntegerType *IT = dyn_cast<IntegerType>(Ty)) { 219045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner switch (IT->getBitWidth()) { 219145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner case 8: 219245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner case 16: 219345bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner case 32: 219445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner case 64: 219545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return true; 219645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner default: break; 219745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner } 219845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner } 219945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return false; 220045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 220145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 22021ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner/// getNumElements - Return the number of elements in the array or vector. 22031ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattnerunsigned ConstantDataSequential::getNumElements() const { 2204af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(getType())) 2205af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner return AT->getNumElements(); 2206230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return getType()->getVectorNumElements(); 22071ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner} 22081ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 22091ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 221045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementByteSize - Return the size in bytes of the elements in the data. 221145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattneruint64_t ConstantDataSequential::getElementByteSize() const { 221245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return getElementType()->getPrimitiveSizeInBits()/8; 221345bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 221445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 221545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementPointer - Return the start of the specified element. 221645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattnerconst char *ConstantDataSequential::getElementPointer(unsigned Elt) const { 22171ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner assert(Elt < getNumElements() && "Invalid Elt"); 221845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return DataElements+Elt*getElementByteSize(); 221945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 222045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 222145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 222227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// isAllZeros - return true if the array is empty or all zeros. 222327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattnerstatic bool isAllZeros(StringRef Arr) { 222427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner for (StringRef::iterator I = Arr.begin(), E = Arr.end(); I != E; ++I) 222527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner if (*I != 0) 222627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return false; 222727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return true; 222827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 2229ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 223027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// getImpl - This is the underlying implementation of all of the 223127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// ConstantDataSequential::get methods. They all thunk down to here, providing 22328cf27efe4000c194efec4004afa83d12031c6d55Chris Lattner/// the correct element type. We take the bytes in as a StringRef because 223327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// we *want* an underlying "char*" to avoid TBAA type punning violations. 223427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris LattnerConstant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) { 2235230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner assert(isElementTypeCompatible(Ty->getSequentialElementType())); 223629cc6cb4d1aa22f0a27edf4e5b363071a83a65d8Chris Lattner // If the elements are all zero or there are no elements, return a CAZ, which 223729cc6cb4d1aa22f0a27edf4e5b363071a83a65d8Chris Lattner // is more dense and canonical. 223827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner if (isAllZeros(Elements)) 223927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return ConstantAggregateZero::get(Ty); 224027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 224127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Do a lookup to see if we have already formed one of these. 224227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner StringMap<ConstantDataSequential*>::MapEntryTy &Slot = 224327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Ty->getContext().pImpl->CDSConstants.GetOrCreateValue(Elements); 2244a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 224527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // The bucket can point to a linked list of different CDS's that have the same 224627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // body but different types. For example, 0,0,0,1 could be a 4 element array 224727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // of i8, or a 1-element array of i32. They'll both end up in the same 224827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner /// StringMap bucket, linked up by their Next pointers. Walk the list. 224927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner ConstantDataSequential **Entry = &Slot.getValue(); 225027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner for (ConstantDataSequential *Node = *Entry; Node != 0; 225127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Entry = &Node->Next, Node = *Entry) 225227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner if (Node->getType() == Ty) 225327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return Node; 2254a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 225527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Okay, we didn't get a hit. Create a node of the right class, link it in, 225627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // and return it. 225727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner if (isa<ArrayType>(Ty)) 225827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return *Entry = new ConstantDataArray(Ty, Slot.getKeyData()); 225927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 226027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner assert(isa<VectorType>(Ty)); 226127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return *Entry = new ConstantDataVector(Ty, Slot.getKeyData()); 226227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 226327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 226427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattnervoid ConstantDataSequential::destroyConstant() { 226527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Remove the constant from the StringMap. 226627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner StringMap<ConstantDataSequential*> &CDSConstants = 226727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner getType()->getContext().pImpl->CDSConstants; 2268a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 226927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner StringMap<ConstantDataSequential*>::iterator Slot = 22709e631da253bff90d9da5ace21bd73f1c838e72ebChris Lattner CDSConstants.find(getRawDataValues()); 227127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 227227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner assert(Slot != CDSConstants.end() && "CDS not found in uniquing table"); 227327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 227427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner ConstantDataSequential **Entry = &Slot->getValue(); 227527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 227627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Remove the entry from the hash table. 227727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner if ((*Entry)->Next == 0) { 227827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // If there is only one value in the bucket (common case) it must be this 227927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // entry, and removing the entry should remove the bucket completely. 228027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner assert((*Entry) == this && "Hash mismatch in ConstantDataSequential"); 228127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner getContext().pImpl->CDSConstants.erase(Slot); 228227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner } else { 228327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Otherwise, there are multiple entries linked off the bucket, unlink the 228427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // node we care about but keep the bucket around. 228527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner for (ConstantDataSequential *Node = *Entry; ; 228627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Entry = &Node->Next, Node = *Entry) { 228727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner assert(Node && "Didn't find entry in its uniquing hash table!"); 228827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // If we found our entry, unlink it from the list and we're done. 228927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner if (Node == this) { 229027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner *Entry = Node->Next; 229127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner break; 229227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner } 229327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner } 229427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner } 2295a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 229627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // If we were part of a list, make sure that we don't delete the list that is 229727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // still owned by the uniquing map. 229827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Next = 0; 2299a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 230027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Finally, actually delete it. 230127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner destroyConstantImpl(); 230227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 230327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 230427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// get() constructors - Return a constant with array type with an element 230527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// count and element type matching the ArrayRef passed in. Note that this 230627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// can return a ConstantAggregateZero object. 230732100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint8_t> Elts) { 230827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getInt8Ty(Context), Elts.size()); 2309a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2310a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*1), Ty); 231127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 231232100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint16_t> Elts){ 231327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getInt16Ty(Context), Elts.size()); 2314a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2315a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*2), Ty); 231627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 231732100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint32_t> Elts){ 231827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getInt32Ty(Context), Elts.size()); 2319a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2320a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); 232127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 232232100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint64_t> Elts){ 232327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getInt64Ty(Context), Elts.size()); 2324a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2325a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); 232627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 232732100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<float> Elts) { 232827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getFloatTy(Context), Elts.size()); 2329a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2330a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); 233127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 233232100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<double> Elts) { 233327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getDoubleTy(Context), Elts.size()); 2334a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2335a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); 233627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 233727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 233832100602432657b188db603ca3ab50b487938027Chris Lattner/// getString - This method constructs a CDS and initializes it with a text 233932100602432657b188db603ca3ab50b487938027Chris Lattner/// string. The default behavior (AddNull==true) causes a null terminator to 234032100602432657b188db603ca3ab50b487938027Chris Lattner/// be placed at the end of the array (increasing the length of the string by 234132100602432657b188db603ca3ab50b487938027Chris Lattner/// one more than the StringRef would normally indicate. Pass AddNull=false 234232100602432657b188db603ca3ab50b487938027Chris Lattner/// to disable this behavior. 234332100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::getString(LLVMContext &Context, 234432100602432657b188db603ca3ab50b487938027Chris Lattner StringRef Str, bool AddNull) { 2345a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova if (!AddNull) { 2346a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const uint8_t *Data = reinterpret_cast<const uint8_t *>(Str.data()); 2347a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return get(Context, ArrayRef<uint8_t>(const_cast<uint8_t *>(Data), 2348a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova Str.size())); 2349a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova } 2350a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 235132100602432657b188db603ca3ab50b487938027Chris Lattner SmallVector<uint8_t, 64> ElementVals; 235232100602432657b188db603ca3ab50b487938027Chris Lattner ElementVals.append(Str.begin(), Str.end()); 235332100602432657b188db603ca3ab50b487938027Chris Lattner ElementVals.push_back(0); 235432100602432657b188db603ca3ab50b487938027Chris Lattner return get(Context, ElementVals); 235532100602432657b188db603ca3ab50b487938027Chris Lattner} 235627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 235727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// get() constructors - Return a constant with vector type with an element 235827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// count and element type matching the ArrayRef passed in. Note that this 235927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// can return a ConstantAggregateZero object. 236032100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint8_t> Elts){ 236127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getInt8Ty(Context), Elts.size()); 2362a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2363a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*1), Ty); 236427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 236532100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint16_t> Elts){ 236627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getInt16Ty(Context), Elts.size()); 2367a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2368a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*2), Ty); 236927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 237032100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint32_t> Elts){ 237127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getInt32Ty(Context), Elts.size()); 2372a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2373a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); 237427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 237532100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint64_t> Elts){ 237627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getInt64Ty(Context), Elts.size()); 2377a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2378a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); 237927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 238032100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<float> Elts) { 238127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size()); 2382a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2383a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); 238427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 238532100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<double> Elts) { 238627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size()); 2387a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2388a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); 238927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 239027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 23913c2c954e0baf4c5029f87277d75cc6ca38916f71Chris LattnerConstant *ConstantDataVector::getSplat(unsigned NumElts, Constant *V) { 23923c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner assert(isElementTypeCompatible(V->getType()) && 23933c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner "Element type not compatible with ConstantData"); 23943c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 23953c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner if (CI->getType()->isIntegerTy(8)) { 23963c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner SmallVector<uint8_t, 16> Elts(NumElts, CI->getZExtValue()); 23973c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return get(V->getContext(), Elts); 23983c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner } 23993c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner if (CI->getType()->isIntegerTy(16)) { 24003c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner SmallVector<uint16_t, 16> Elts(NumElts, CI->getZExtValue()); 24013c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return get(V->getContext(), Elts); 24023c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner } 24033c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner if (CI->getType()->isIntegerTy(32)) { 24043c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner SmallVector<uint32_t, 16> Elts(NumElts, CI->getZExtValue()); 24053c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return get(V->getContext(), Elts); 24063c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner } 24073c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner assert(CI->getType()->isIntegerTy(64) && "Unsupported ConstantData type"); 24083c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner SmallVector<uint64_t, 16> Elts(NumElts, CI->getZExtValue()); 24093c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return get(V->getContext(), Elts); 24103c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner } 24113c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner 241236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(V)) { 241336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (CFP->getType()->isFloatTy()) { 241436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<float, 16> Elts(NumElts, CFP->getValueAPF().convertToFloat()); 241536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return get(V->getContext(), Elts); 241636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 241736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (CFP->getType()->isDoubleTy()) { 241836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<double, 16> Elts(NumElts, 241936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner CFP->getValueAPF().convertToDouble()); 242036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return get(V->getContext(), Elts); 242136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 24223c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner } 242336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantVector::getSplat(NumElts, V); 24243c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner} 24253c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner 24263c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner 242745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementAsInteger - If this is a sequential container of integers (of 242845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// any size), return the specified element in the low bits of a uint64_t. 242945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattneruint64_t ConstantDataSequential::getElementAsInteger(unsigned Elt) const { 243045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner assert(isa<IntegerType>(getElementType()) && 243145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner "Accessor can only be used when element is an integer"); 243245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner const char *EltPtr = getElementPointer(Elt); 2433a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 243445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner // The data is stored in host byte order, make sure to cast back to the right 243545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner // type to load with the right endianness. 2436230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner switch (getElementType()->getIntegerBitWidth()) { 243750bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper default: llvm_unreachable("Invalid bitwidth for CDS"); 2438a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case 8: 2439a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(EltPtr)); 2440a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case 16: 2441a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<uint16_t *>(reinterpret_cast<const uint16_t *>(EltPtr)); 2442a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case 32: 2443a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<uint32_t *>(reinterpret_cast<const uint32_t *>(EltPtr)); 2444a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case 64: 2445a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<uint64_t *>(reinterpret_cast<const uint64_t *>(EltPtr)); 244645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner } 244745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 244845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 244945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementAsAPFloat - If this is a sequential container of floating point 245045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// type, return the specified element as an APFloat. 245145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris LattnerAPFloat ConstantDataSequential::getElementAsAPFloat(unsigned Elt) const { 245245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner const char *EltPtr = getElementPointer(Elt); 245345bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 245445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner switch (getElementType()->getTypeID()) { 24551486ae626f1af5c2797f4d13e9c57b3a0e473811Nick Lewycky default: 245650bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("Accessor can only be used when element is float/double!"); 2457a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case Type::FloatTyID: { 2458a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const float *FloatPrt = reinterpret_cast<const float *>(EltPtr); 2459a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return APFloat(*const_cast<float *>(FloatPrt)); 2460a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova } 2461a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case Type::DoubleTyID: { 2462a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const double *DoublePtr = reinterpret_cast<const double *>(EltPtr); 2463a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return APFloat(*const_cast<double *>(DoublePtr)); 2464a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova } 246545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner } 246645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 246745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 246845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementAsFloat - If this is an sequential container of floats, return 246945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// the specified element as a float. 247045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattnerfloat ConstantDataSequential::getElementAsFloat(unsigned Elt) const { 247145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner assert(getElementType()->isFloatTy() && 247245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner "Accessor can only be used when element is a 'float'"); 2473a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const float *EltPtr = reinterpret_cast<const float *>(getElementPointer(Elt)); 2474a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<float *>(EltPtr); 247545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 247645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 247745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementAsDouble - If this is an sequential container of doubles, return 247845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// the specified element as a float. 247945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattnerdouble ConstantDataSequential::getElementAsDouble(unsigned Elt) const { 248045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner assert(getElementType()->isDoubleTy() && 248145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner "Accessor can only be used when element is a 'float'"); 2482a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const double *EltPtr = 2483a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova reinterpret_cast<const double *>(getElementPointer(Elt)); 2484a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<double *>(EltPtr); 248545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 248645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 248745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementAsConstant - Return a Constant for a specified index's element. 248845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// Note that this has to compute a new constant to return, so it isn't as 248945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// efficient as getElementAsInteger/Float/Double. 249045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris LattnerConstant *ConstantDataSequential::getElementAsConstant(unsigned Elt) const { 249145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner if (getElementType()->isFloatTy() || getElementType()->isDoubleTy()) 249245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return ConstantFP::get(getContext(), getElementAsAPFloat(Elt)); 2493a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 249445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return ConstantInt::get(getElementType(), getElementAsInteger(Elt)); 249545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 249645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 249762339073127df4579905f551f61c132cf21d2aadChris Lattner/// isString - This method returns true if this is an array of i8. 249862339073127df4579905f551f61c132cf21d2aadChris Lattnerbool ConstantDataSequential::isString() const { 249962339073127df4579905f551f61c132cf21d2aadChris Lattner return isa<ArrayType>(getType()) && getElementType()->isIntegerTy(8); 250062339073127df4579905f551f61c132cf21d2aadChris Lattner} 250162339073127df4579905f551f61c132cf21d2aadChris Lattner 250262339073127df4579905f551f61c132cf21d2aadChris Lattner/// isCString - This method returns true if the array "isString", ends with a 250362339073127df4579905f551f61c132cf21d2aadChris Lattner/// nul byte, and does not contains any other nul bytes. 250462339073127df4579905f551f61c132cf21d2aadChris Lattnerbool ConstantDataSequential::isCString() const { 250562339073127df4579905f551f61c132cf21d2aadChris Lattner if (!isString()) 250662339073127df4579905f551f61c132cf21d2aadChris Lattner return false; 2507a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 250862339073127df4579905f551f61c132cf21d2aadChris Lattner StringRef Str = getAsString(); 2509a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 251062339073127df4579905f551f61c132cf21d2aadChris Lattner // The last value must be nul. 251162339073127df4579905f551f61c132cf21d2aadChris Lattner if (Str.back() != 0) return false; 2512a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 251362339073127df4579905f551f61c132cf21d2aadChris Lattner // Other elements must be non-nul. 251462339073127df4579905f551f61c132cf21d2aadChris Lattner return Str.drop_back().find(0) == StringRef::npos; 251562339073127df4579905f551f61c132cf21d2aadChris Lattner} 251627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 2517e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner/// getSplatValue - If this is a splat constant, meaning that all of the 2518e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner/// elements have the same value, return that value. Otherwise return NULL. 2519e150e2df424b162710b36a1ec5ef90270ffb435bChris LattnerConstant *ConstantDataVector::getSplatValue() const { 2520e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner const char *Base = getRawDataValues().data(); 2521a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2522e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner // Compare elements 1+ to the 0'th element. 2523e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner unsigned EltSize = getElementByteSize(); 2524e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner for (unsigned i = 1, e = getNumElements(); i != e; ++i) 2525e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (memcmp(Base, Base+i*EltSize, EltSize)) 2526e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner return 0; 2527a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2528e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner // If they're all the same, return the 0th one as a representative. 2529e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner return getElementAsConstant(0); 2530e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner} 253104e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner 25325cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner//===----------------------------------------------------------------------===// 25335cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner// replaceUsesOfWithOnConstant implementations 25345cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner 25355498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// replaceUsesOfWithOnConstant - Update this constant array to change uses of 25365498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// 'From' to be uses of 'To'. This must update the uniquing data structures 25375498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// etc. 25385498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// 25395498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// Note that we intentionally replace all uses of From with To here. Consider 25405498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// a large array that uses 'From' 1000 times. By handling this case all here, 25415498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// ConstantArray::replaceUsesOfWithOnConstant is only invoked once, and that 25425498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// single invocation handles all 1000 uses. Handling them one at a time would 25435498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// work, but would be really slow because it would have to unique each updated 25445498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// array instance. 25452ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner/// 25465cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattnervoid ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To, 2547d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner Use *U) { 25481fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!"); 25491fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson Constant *ToC = cast<Constant>(To); 25501fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson 25511afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner LLVMContextImpl *pImpl = getType()->getContext().pImpl; 25521fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson 25532cb395eae71dacda49ca3fe758618fc3e0701659Talin SmallVector<Constant*, 8> Values; 25542cb395eae71dacda49ca3fe758618fc3e0701659Talin LLVMContextImpl::ArrayConstantsTy::LookupKey Lookup; 25552cb395eae71dacda49ca3fe758618fc3e0701659Talin Lookup.first = cast<ArrayType>(getType()); 25561fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson Values.reserve(getNumOperands()); // Build replacement array. 25571fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson 2558a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova // Fill values with the modified operands of the constant array. Also, 25591fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // compute whether this turns into an all-zeros array. 25601fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson unsigned NumUpdated = 0; 2561a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2562e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner // Keep track of whether all the values in the array are "ToC". 2563e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner bool AllSame = true; 2564e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) { 2565e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Constant *Val = cast<Constant>(O->get()); 2566e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (Val == From) { 2567e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Val = ToC; 2568e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner ++NumUpdated; 25691fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } 2570e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Values.push_back(Val); 25712cb395eae71dacda49ca3fe758618fc3e0701659Talin AllSame &= Val == ToC; 25721fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } 2573a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 25741fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson Constant *Replacement = 0; 2575e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (AllSame && ToC->isNullValue()) { 25761afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Replacement = ConstantAggregateZero::get(getType()); 2577e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } else if (AllSame && isa<UndefValue>(ToC)) { 2578e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Replacement = UndefValue::get(getType()); 25791fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } else { 25801fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // Check to see if we have this array type already. 25812cb395eae71dacda49ca3fe758618fc3e0701659Talin Lookup.second = makeArrayRef(Values); 25821fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson LLVMContextImpl::ArrayConstantsTy::MapTy::iterator I = 25832cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->ArrayConstants.find(Lookup); 2584a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 25852cb395eae71dacda49ca3fe758618fc3e0701659Talin if (I != pImpl->ArrayConstants.map_end()) { 25862cb395eae71dacda49ca3fe758618fc3e0701659Talin Replacement = I->first; 25871fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } else { 25881fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // Okay, the new shape doesn't exist in the system yet. Instead of 25891fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // creating a new constant array, inserting it, replaceallusesof'ing the 25901fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // old with the new, then deleting the old... just update the current one 25911fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // in place! 25922cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->ArrayConstants.remove(this); 2593a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 25941fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // Update to the new value. Optimize for the case when we have a single 25951fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // operand that we're changing, but handle bulk updates efficiently. 25961fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson if (NumUpdated == 1) { 25971fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson unsigned OperandToUpdate = U - OperandList; 25981fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson assert(getOperand(OperandToUpdate) == From && 25991fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson "ReplaceAllUsesWith broken!"); 26001fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson setOperand(OperandToUpdate, ToC); 26011fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } else { 26021fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 26031fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson if (getOperand(i) == From) 26041fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson setOperand(i, ToC); 26051fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } 26062cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->ArrayConstants.insert(this); 26071fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson return; 26081fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } 26091fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } 2610a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2611cea141f1d1f85997c4c657009994bdacbc3a3dbfChris Lattner // Otherwise, I do need to replace this with an existing value. 26125cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner assert(Replacement != this && "I didn't contain From!"); 2613a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2614d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner // Everyone using this now uses the replacement. 2615678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner replaceAllUsesWith(Replacement); 2616a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 26175cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner // Delete the old constant! 26185cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner destroyConstant(); 26195cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner} 26205cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner 26215cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattnervoid ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To, 2622d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner Use *U) { 26238fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!"); 26248fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Constant *ToC = cast<Constant>(To); 26258fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson 26268fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson unsigned OperandToUpdate = U-OperandList; 26278fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!"); 26288fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson 26292cb395eae71dacda49ca3fe758618fc3e0701659Talin SmallVector<Constant*, 8> Values; 26302cb395eae71dacda49ca3fe758618fc3e0701659Talin LLVMContextImpl::StructConstantsTy::LookupKey Lookup; 26312cb395eae71dacda49ca3fe758618fc3e0701659Talin Lookup.first = cast<StructType>(getType()); 26328fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Values.reserve(getNumOperands()); // Build replacement struct. 2633a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2634a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova // Fill values with the modified operands of the constant struct. Also, 26358fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // compute whether this turns into an all-zeros struct. 26368fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson bool isAllZeros = false; 2637e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner bool isAllUndef = false; 2638e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (ToC->isNullValue()) { 26398fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson isAllZeros = true; 26408fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) { 26418fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Constant *Val = cast<Constant>(O->get()); 26428fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Values.push_back(Val); 26438fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson if (isAllZeros) isAllZeros = Val->isNullValue(); 26448fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } 2645e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } else if (isa<UndefValue>(ToC)) { 2646e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner isAllUndef = true; 2647e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) { 2648e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Constant *Val = cast<Constant>(O->get()); 2649e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Values.push_back(Val); 2650e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (isAllUndef) isAllUndef = isa<UndefValue>(Val); 2651e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } 2652e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } else { 2653e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O) 2654e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Values.push_back(cast<Constant>(O->get())); 26558fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } 26568fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Values[OperandToUpdate] = ToC; 2657a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 26581afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner LLVMContextImpl *pImpl = getContext().pImpl; 2659a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 26608fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Constant *Replacement = 0; 26618fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson if (isAllZeros) { 26621afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Replacement = ConstantAggregateZero::get(getType()); 2663e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } else if (isAllUndef) { 2664e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Replacement = UndefValue::get(getType()); 26658fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } else { 266693604b6de20f6a2ce160bfa65ef5d99cc8e577f3Chris Lattner // Check to see if we have this struct type already. 26672cb395eae71dacda49ca3fe758618fc3e0701659Talin Lookup.second = makeArrayRef(Values); 26688fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson LLVMContextImpl::StructConstantsTy::MapTy::iterator I = 26692cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->StructConstants.find(Lookup); 2670a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 26712cb395eae71dacda49ca3fe758618fc3e0701659Talin if (I != pImpl->StructConstants.map_end()) { 26722cb395eae71dacda49ca3fe758618fc3e0701659Talin Replacement = I->first; 26738fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } else { 26748fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // Okay, the new shape doesn't exist in the system yet. Instead of 26758fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // creating a new constant struct, inserting it, replaceallusesof'ing the 26768fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // old with the new, then deleting the old... just update the current one 26778fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // in place! 26782cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->StructConstants.remove(this); 2679a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 26808fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // Update to the new value. 26818fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson setOperand(OperandToUpdate, ToC); 26822cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->StructConstants.insert(this); 26838fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson return; 26848fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } 26858fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } 2686a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 26878fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson assert(Replacement != this && "I didn't contain From!"); 2688a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2689d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner // Everyone using this now uses the replacement. 2690678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner replaceAllUsesWith(Replacement); 2691a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 26925cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner // Delete the old constant! 26935cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner destroyConstant(); 26945cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner} 26955cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner 26969d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencervoid ConstantVector::replaceUsesOfWithOnConstant(Value *From, Value *To, 2697d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner Use *U) { 26985cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!"); 2699a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2700a7c698823e4ffa4589bde1ff6de60b6af0cdba5aChris Lattner SmallVector<Constant*, 8> Values; 27015cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner Values.reserve(getNumOperands()); // Build replacement array... 27025cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 27035cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner Constant *Val = getOperand(i); 27045cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner if (Val == From) Val = cast<Constant>(To); 27055cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner Values.push_back(Val); 27065cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner } 2707a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2708a0c138429e101f573d43740322245c1d5b8b04a0Jay Foad Constant *Replacement = get(Values); 27095cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner assert(Replacement != this && "I didn't contain From!"); 2710a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2711d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner // Everyone using this now uses the replacement. 2712678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner replaceAllUsesWith(Replacement); 2713a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 27145cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner // Delete the old constant! 27155cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner destroyConstant(); 27165cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner} 27175cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner 27185cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattnervoid ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV, 2719d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner Use *U) { 27205cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!"); 27215cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner Constant *To = cast<Constant>(ToV); 2722a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 27231a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner SmallVector<Constant*, 8> NewOps; 27241a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 27251a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner Constant *Op = getOperand(i); 27261a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner NewOps.push_back(Op == From ? To : Op); 27275cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner } 2728a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 27291a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner Constant *Replacement = getWithOperands(NewOps); 27305cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner assert(Replacement != this && "I didn't contain From!"); 2731a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2732d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner // Everyone using this now uses the replacement. 2733678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner replaceAllUsesWith(Replacement); 2734a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 27355cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner // Delete the old constant! 27365cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner destroyConstant(); 273710b9de62ff14069a4410f6005eaf71d353b2ac83Matthijs Kooijman} 2738b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2739b9478c2aef060aa6b0ede41c05859c34b1527bf8James MolloyInstruction *ConstantExpr::getAsInstruction() { 2740b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy SmallVector<Value*,4> ValueOperands; 2741b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy for (op_iterator I = op_begin(), E = op_end(); I != E; ++I) 2742b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy ValueOperands.push_back(cast<Value>(I)); 2743b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2744b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy ArrayRef<Value*> Ops(ValueOperands); 2745b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2746b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy switch (getOpcode()) { 2747b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::Trunc: 2748b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::ZExt: 2749b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::SExt: 2750b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::FPTrunc: 2751b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::FPExt: 2752b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::UIToFP: 2753b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::SIToFP: 2754b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::FPToUI: 2755b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::FPToSI: 2756b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::PtrToInt: 2757b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::IntToPtr: 2758b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::BitCast: 2759b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return CastInst::Create((Instruction::CastOps)getOpcode(), 2760b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy Ops[0], getType()); 2761b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::Select: 2762b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return SelectInst::Create(Ops[0], Ops[1], Ops[2]); 2763b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::InsertElement: 2764b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return InsertElementInst::Create(Ops[0], Ops[1], Ops[2]); 2765b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::ExtractElement: 2766b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return ExtractElementInst::Create(Ops[0], Ops[1]); 2767b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::InsertValue: 2768b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return InsertValueInst::Create(Ops[0], Ops[1], getIndices()); 2769b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::ExtractValue: 2770b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return ExtractValueInst::Create(Ops[0], getIndices()); 2771b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::ShuffleVector: 2772b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return new ShuffleVectorInst(Ops[0], Ops[1], Ops[2]); 2773b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2774b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::GetElementPtr: 2775b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy if (cast<GEPOperator>(this)->isInBounds()) 2776b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return GetElementPtrInst::CreateInBounds(Ops[0], Ops.slice(1)); 2777b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy else 2778b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return GetElementPtrInst::Create(Ops[0], Ops.slice(1)); 2779b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2780b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::ICmp: 2781b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::FCmp: 2782b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return CmpInst::Create((Instruction::OtherOps)getOpcode(), 2783b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy getPredicate(), Ops[0], Ops[1]); 2784b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2785b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy default: 2786b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy assert(getNumOperands() == 2 && "Must be binary operator?"); 2787b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy BinaryOperator *BO = 2788b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy BinaryOperator::Create((Instruction::BinaryOps)getOpcode(), 2789b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy Ops[0], Ops[1]); 2790b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy if (isa<OverflowingBinaryOperator>(BO)) { 2791b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy BO->setHasNoUnsignedWrap(SubclassOptionalData & 2792b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy OverflowingBinaryOperator::NoUnsignedWrap); 2793b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy BO->setHasNoSignedWrap(SubclassOptionalData & 2794b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy OverflowingBinaryOperator::NoSignedWrap); 2795b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy } 2796b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy if (isa<PossiblyExactOperator>(BO)) 2797b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy BO->setIsExact(SubclassOptionalData & PossiblyExactOperator::IsExact); 2798b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return BO; 2799b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy } 2800b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy} 2801