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" 2436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines#include "llvm/IR/GetElementPtrTypeIterator.h" 250b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/GlobalValue.h" 260b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Instructions.h" 270b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Module.h" 280b8c9a80f20772c3793201ab5b251d3520b9cea3Chandler Carruth#include "llvm/IR/Operator.h" 29a4f0b3a084d120cfc5b5bb06f64b222f5cb72740Chris Lattner#include "llvm/Support/Compiler.h" 302e3def1177c462e14b20ddad71adf5c6b7c3e867Bill Wendling#include "llvm/Support/Debug.h" 317d696d80409aad20bb5da0fc4eccab941dd371d4Torok Edwin#include "llvm/Support/ErrorHandling.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 110cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hinesbool Constant::isMinSignedValue() const { 111cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // Check for INT_MIN integers 112cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (const ConstantInt *CI = dyn_cast<ConstantInt>(this)) 113cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return CI->isMinValue(/*isSigned=*/true); 114cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 115cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // Check for FP which are bitcasted from INT_MIN integers 116cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (const ConstantFP *CFP = dyn_cast<ConstantFP>(this)) 117cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return CFP->getValueAPF().bitcastToAPInt().isMinSignedValue(); 118cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 119cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // Check for constant vectors which are splats of INT_MIN values. 120cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) 121cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (Constant *Splat = CV->getSplatValue()) 122cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return Splat->isMinSignedValue(); 123cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 124cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // Check for constant vectors which are splats of INT_MIN values. 125cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) 126cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (Constant *Splat = CV->getSplatValue()) 127cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return Splat->isMinSignedValue(); 128cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 129cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return false; 130cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines} 131cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 132a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson// Constructor to create a '0' constant of arbitrary type... 133db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *Constant::getNullValue(Type *Ty) { 134a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson switch (Ty->getTypeID()) { 135a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::IntegerTyID: 136a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return ConstantInt::get(Ty, 0); 137ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman case Type::HalfTyID: 138ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return ConstantFP::get(Ty->getContext(), 139ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman APFloat::getZero(APFloat::IEEEhalf)); 140a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::FloatTyID: 141983839609ffa589cda60efaea847eecede77b524Benjamin Kramer return ConstantFP::get(Ty->getContext(), 142983839609ffa589cda60efaea847eecede77b524Benjamin Kramer APFloat::getZero(APFloat::IEEEsingle)); 143a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::DoubleTyID: 144983839609ffa589cda60efaea847eecede77b524Benjamin Kramer return ConstantFP::get(Ty->getContext(), 145983839609ffa589cda60efaea847eecede77b524Benjamin Kramer APFloat::getZero(APFloat::IEEEdouble)); 146a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::X86_FP80TyID: 147983839609ffa589cda60efaea847eecede77b524Benjamin Kramer return ConstantFP::get(Ty->getContext(), 148983839609ffa589cda60efaea847eecede77b524Benjamin Kramer APFloat::getZero(APFloat::x87DoubleExtended)); 149a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::FP128TyID: 150a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return ConstantFP::get(Ty->getContext(), 151983839609ffa589cda60efaea847eecede77b524Benjamin Kramer APFloat::getZero(APFloat::IEEEquad)); 152a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::PPC_FP128TyID: 153983839609ffa589cda60efaea847eecede77b524Benjamin Kramer return ConstantFP::get(Ty->getContext(), 1540a29cb045444c13160e90fe7942a9d7c720185edTim Northover APFloat(APFloat::PPCDoubleDouble, 1550a29cb045444c13160e90fe7942a9d7c720185edTim Northover APInt::getNullValue(128))); 156a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::PointerTyID: 157a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return ConstantPointerNull::get(cast<PointerType>(Ty)); 158a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::StructTyID: 159a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::ArrayTyID: 160a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson case Type::VectorTyID: 161a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return ConstantAggregateZero::get(Ty); 162a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson default: 163a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson // Function, Label, or Opaque type? 16450bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("Cannot create a null constant of that type!"); 165a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson } 166a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson} 167a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson 168db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *Constant::getIntegerValue(Type *Ty, const APInt &V) { 169db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ScalarTy = Ty->getScalarType(); 17043ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman 17143ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman // Create the base integer constant. 17243ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman Constant *C = ConstantInt::get(Ty->getContext(), V); 17343ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman 17443ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman // Convert an integer to a pointer, if necessary. 175db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (PointerType *PTy = dyn_cast<PointerType>(ScalarTy)) 17643ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman C = ConstantExpr::getIntToPtr(C, PTy); 17743ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman 17843ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman // Broadcast a scalar to a vector, if necessary. 179db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 1803c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner C = ConstantVector::getSplat(VTy->getNumElements(), C); 18143ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman 18243ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman return C; 18343ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman} 18443ee5f7c08bd5a91cdd8681df20a7d1df26a1024Dan Gohman 185db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *Constant::getAllOnesValue(Type *Ty) { 186db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (IntegerType *ITy = dyn_cast<IntegerType>(Ty)) 187a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return ConstantInt::get(Ty->getContext(), 188a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson APInt::getAllOnesValue(ITy->getBitWidth())); 189093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem 190093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem if (Ty->isFloatingPointTy()) { 191093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem APFloat FL = APFloat::getAllOnesValue(Ty->getPrimitiveSizeInBits(), 192093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem !Ty->isPPC_FP128Ty()); 193093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem return ConstantFP::get(Ty->getContext(), FL); 194093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem } 195093399cbf3bcdb31d04b3bf5c5691fc88c25da48Nadav Rotem 196db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *VTy = cast<VectorType>(Ty); 1973c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), 1983c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner getAllOnesValue(VTy->getElementType())); 199a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson} 200a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson 2013d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner/// getAggregateElement - For aggregates (struct/array/vector) return the 2023d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner/// constant that corresponds to the specified element if possible, or null if 2033d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner/// not. This can return null if the element index is a ConstantExpr, or if 2043d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner/// 'this' is a constant expr. 2053d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *Constant::getAggregateElement(unsigned Elt) const { 2063d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (const ConstantStruct *CS = dyn_cast<ConstantStruct>(this)) 207dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return Elt < CS->getNumOperands() ? CS->getOperand(Elt) : nullptr; 208a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2093d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (const ConstantArray *CA = dyn_cast<ConstantArray>(this)) 210dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return Elt < CA->getNumOperands() ? CA->getOperand(Elt) : nullptr; 211a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2123d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) 213dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return Elt < CV->getNumOperands() ? CV->getOperand(Elt) : nullptr; 214a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2153d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (const ConstantAggregateZero *CAZ =dyn_cast<ConstantAggregateZero>(this)) 2163d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner return CAZ->getElementValue(Elt); 217a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2183d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (const UndefValue *UV = dyn_cast<UndefValue>(this)) 2193d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner return UV->getElementValue(Elt); 220a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 221230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (const ConstantDataSequential *CDS =dyn_cast<ConstantDataSequential>(this)) 222dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return Elt < CDS->getNumElements() ? CDS->getElementAsConstant(Elt) 223dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : nullptr; 224dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2253d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner} 2263d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner 2273d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *Constant::getAggregateElement(Constant *Elt) const { 2283d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner assert(isa<IntegerType>(Elt->getType()) && "Index must be an integer"); 2293d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(Elt)) 2303d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner return getAggregateElement(CI->getZExtValue()); 231dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2323d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner} 2333d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner 2343d5ed2250e78c3e849232398cb550238155dbb72Chris Lattner 2359fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattnervoid Constant::destroyConstantImpl() { 2369fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // When a Constant is destroyed, there may be lingering 2379fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // references to the constant by other constants in the constant pool. These 238ef6a6a69ff1e1b709d0acb315b9f6c926c67a778Misha Brukman // constants are implicitly dependent on the module that is being deleted, 2399fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // but they don't know that. Because we only find out when the CPV is 2409fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // deleted, we must now notify all of our users (that should only be 2419fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // Constants) that they are, in fact, invalid now and should be deleted. 2429fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // 2439fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner while (!use_empty()) { 24436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Value *V = user_back(); 2459fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner#ifndef NDEBUG // Only in -g mode... 24637f077a8dad6a6a307204ec98f6d155c1576d6d2Chris Lattner if (!isa<Constant>(V)) { 247d2e63b7fdbdfd0f6986cc1563a6f0cc9446926c9David Greene dbgs() << "While deleting: " << *this 24837f077a8dad6a6a307204ec98f6d155c1576d6d2Chris Lattner << "\n\nUse still stuck around after Def is destroyed: " 24937f077a8dad6a6a307204ec98f6d155c1576d6d2Chris Lattner << *V << "\n\n"; 25037f077a8dad6a6a307204ec98f6d155c1576d6d2Chris Lattner } 2519fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner#endif 2529fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner assert(isa<Constant>(V) && "References remain to Constant being destroyed"); 253230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner cast<Constant>(V)->destroyConstant(); 2549fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner 2559fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // The constant should remove itself from our use list... 25636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert((use_empty() || user_back() != V) && "Constant not removed!"); 2579fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner } 2589fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner 2599fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner // Value has no outstanding references it is safe to delete it now... 2609fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner delete this; 2619fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner} 2629fb96412ae530963cae855ee2dd03da5719c7d6bChris Lattner 2638848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramerstatic bool canTrapImpl(const Constant *C, 2648848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer SmallPtrSet<const ConstantExpr *, 4> &NonTrappingOps) { 2658848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer assert(C->getType()->isFirstClassType() && "Cannot evaluate aggregate vals!"); 26635b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner // The only thing that could possibly trap are constant exprs. 2678848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer const ConstantExpr *CE = dyn_cast<ConstantExpr>(C); 2688848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer if (!CE) 2698848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer return false; 270a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 271a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova // ConstantExpr traps if any operands can trap. 2728848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer for (unsigned i = 0, e = C->getNumOperands(); i != e; ++i) { 2738848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer if (ConstantExpr *Op = dyn_cast<ConstantExpr>(CE->getOperand(i))) { 2748848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer if (NonTrappingOps.insert(Op) && canTrapImpl(Op, NonTrappingOps)) 2758848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer return true; 2768848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer } 2778848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer } 27835b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner 27935b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner // Otherwise, only specific operations can trap. 28035b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner switch (CE->getOpcode()) { 28135b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner default: 28235b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner return false; 2831628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::UDiv: 2841628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::SDiv: 2851628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::FDiv: 2860a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::URem: 2870a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::SRem: 2880a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::FRem: 28935b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner // Div and rem can trap if the RHS is not known to be non-zero. 2900eeb913aa17a68b1f2963b02ca1d68f09dba0b78Chris Lattner if (!isa<ConstantInt>(CE->getOperand(1)) ||CE->getOperand(1)->isNullValue()) 29135b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner return true; 29235b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner return false; 29335b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner } 29435b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner} 29535b89fa63957c4d6468cd50af2a91ed92db44d49Chris Lattner 2968848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer/// canTrap - Return true if evaluation of this constant could trap. This is 2978848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer/// true for things like constant expressions that could divide by zero. 2988848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramerbool Constant::canTrap() const { 2998848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer SmallPtrSet<const ConstantExpr *, 4> NonTrappingOps; 3008848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer return canTrapImpl(this, NonTrappingOps); 3018848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer} 3028848680ce0ab416cb646d0a03aa6f4f6f25e7623Benjamin Kramer 303cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines/// Check if C contains a GlobalValue for which Predicate is true. 304cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hinesstatic bool 305cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen HinesConstHasGlobalValuePredicate(const Constant *C, 306cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines bool (*Predicate)(const GlobalValue *)) { 307cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SmallPtrSet<const Constant *, 8> Visited; 308cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines SmallVector<const Constant *, 8> WorkList; 309cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines WorkList.push_back(C); 310cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines Visited.insert(C); 3111839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg 3121839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg while (!WorkList.empty()) { 313cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines const Constant *WorkItem = WorkList.pop_back_val(); 314cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (const auto *GV = dyn_cast<GlobalValue>(WorkItem)) 315cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (Predicate(GV)) 3161839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg return true; 317cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines for (const Value *Op : WorkItem->operands()) { 318cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines const Constant *ConstOp = dyn_cast<Constant>(Op); 319cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (!ConstOp) 320fbeb956876573ae9ec6ddd190eb37e9174489c79Hans Wennborg continue; 321cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (Visited.insert(ConstOp)) 322cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines WorkList.push_back(ConstOp); 3231839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg } 3241839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg } 3251839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg return false; 3261839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg} 3271839858983dcbaf1808a6a37f5cd64d92981f27eHans Wennborg 328cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines/// Return true if the value can vary between threads. 329cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hinesbool Constant::isThreadDependent() const { 330cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines auto DLLImportPredicate = [](const GlobalValue *GV) { 331cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return GV->isThreadLocal(); 332cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines }; 333cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return ConstHasGlobalValuePredicate(this, DLLImportPredicate); 334cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines} 335cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 336cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hinesbool Constant::isDLLImportDependent() const { 337cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines auto DLLImportPredicate = [](const GlobalValue *GV) { 338cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return GV->hasDLLImportStorageClass(); 339cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines }; 340cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines return ConstHasGlobalValuePredicate(this, DLLImportPredicate); 341cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines} 342cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines 343cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines/// Return true if the constant has users other than constant exprs and other 344cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines/// dangling things. 3454a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattnerbool Constant::isConstantUsed() const { 34636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines for (const User *U : users()) { 34736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const Constant *UC = dyn_cast<Constant>(U); 348dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!UC || isa<GlobalValue>(UC)) 3494a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner return true; 350a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 3514a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner if (UC->isConstantUsed()) 3524a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner return true; 3534a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner } 3544a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner return false; 3554a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner} 3564a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner 3574a7642ec9c33bcf8ed65231f382fb6d9a0f46f3aChris Lattner 35848738b9244217f9e6638513598f875ff59fbc5e6Anton Korobeynikov 3597cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// getRelocationInfo - This method classifies the entry according to 3607cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// whether or not it may generate a relocation entry. This must be 3617cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// conservative, so if it might codegen to a relocatable entry, it should say 3627cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// so. The return values are: 3637cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// 364083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// NoRelocation: This constant pool entry is guaranteed to never have a 365083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// relocation applied to it (because it holds a simple constant like 366083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// '4'). 367083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// LocalRelocation: This entry has relocations, but the entries are 368083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// guaranteed to be resolvable by the static linker, so the dynamic 369083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// linker will never see them. 370083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner/// GlobalRelocations: This entry may have arbitrary relocations. 3717cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner/// 372c2c50cdcdc19a1bca993c06d13d8cdca87083ce4Chandler Carruth/// FIXME: This really should not be in IR. 373083a1e059768f6844b9f5292223bb49ad24f52d1Chris LattnerConstant::PossibleRelocationsTy Constant::getRelocationInfo() const { 374083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner if (const GlobalValue *GV = dyn_cast<GlobalValue>(this)) { 3757cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner if (GV->hasLocalLinkage() || GV->hasHiddenVisibility()) 376083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner return LocalRelocation; // Local to this file/library. 377083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner return GlobalRelocations; // Global reference. 378ab267a28239f628e65bef34578695d80ba6d0a9eAnton Korobeynikov } 3797cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner 3805d81befc217bdd89ec17979797cfa297985e79d7Chris Lattner if (const BlockAddress *BA = dyn_cast<BlockAddress>(this)) 3815d81befc217bdd89ec17979797cfa297985e79d7Chris Lattner return BA->getFunction()->getRelocationInfo(); 3825d81befc217bdd89ec17979797cfa297985e79d7Chris Lattner 3835099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner // While raw uses of blockaddress need to be relocated, differences between 3845099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner // two of them don't when they are for labels in the same function. This is a 3855099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner // common idiom when creating a table for the indirect goto extension, so we 3865099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner // handle it efficiently here. 3875099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(this)) 3885099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner if (CE->getOpcode() == Instruction::Sub) { 3895099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner ConstantExpr *LHS = dyn_cast<ConstantExpr>(CE->getOperand(0)); 3905099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner ConstantExpr *RHS = dyn_cast<ConstantExpr>(CE->getOperand(1)); 3915099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner if (LHS && RHS && 3925099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner LHS->getOpcode() == Instruction::PtrToInt && 3935099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner RHS->getOpcode() == Instruction::PtrToInt && 3945099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner isa<BlockAddress>(LHS->getOperand(0)) && 3955099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner isa<BlockAddress>(RHS->getOperand(0)) && 3965099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner cast<BlockAddress>(LHS->getOperand(0))->getFunction() == 3975099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner cast<BlockAddress>(RHS->getOperand(0))->getFunction()) 3985099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner return NoRelocation; 3995099b31f98d24989cbb2055fa7e2a4658dba95adChris Lattner } 400a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 401083a1e059768f6844b9f5292223bb49ad24f52d1Chris Lattner PossibleRelocationsTy Result = NoRelocation; 402afe15815571b34d7d53e5a005240686089b18361Evan Cheng for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 4030eeb913aa17a68b1f2963b02ca1d68f09dba0b78Chris Lattner Result = std::max(Result, 4040eeb913aa17a68b1f2963b02ca1d68f09dba0b78Chris Lattner cast<Constant>(getOperand(i))->getRelocationInfo()); 405a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 4067cf12c7efd37dc12c3ed536a3f4c373dddac2b85Chris Lattner return Result; 407afe15815571b34d7d53e5a005240686089b18361Evan Cheng} 408afe15815571b34d7d53e5a005240686089b18361Evan Cheng 40913fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// removeDeadUsersOfConstant - If the specified constantexpr is dead, remove 41013fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// it. This involves recursively eliminating any dead users of the 41113fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// constantexpr. 41213fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattnerstatic bool removeDeadUsersOfConstant(const Constant *C) { 41313fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (isa<GlobalValue>(C)) return false; // Cannot remove this 414a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 41513fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner while (!C->use_empty()) { 41636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const Constant *User = dyn_cast<Constant>(C->user_back()); 41713fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (!User) return false; // Non-constant usage; 41813fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (!removeDeadUsersOfConstant(User)) 41913fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner return false; // Constant wasn't dead 42013fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } 421a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 42213fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner const_cast<Constant*>(C)->destroyConstant(); 42313fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner return true; 42413fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner} 42513fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner 42613fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner 42713fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// removeDeadConstantUsers - If there are any dead constant users dangling 42813fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// off of this constant, remove them. This method is useful for clients 42913fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// that want to check to see if a global is unused, but don't want to deal 43013fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner/// with potentially dead constants hanging off of the globals. 43113fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattnervoid Constant::removeDeadConstantUsers() const { 43236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Value::const_user_iterator I = user_begin(), E = user_end(); 43336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Value::const_user_iterator LastNonDeadUser = E; 43413fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner while (I != E) { 43513fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner const Constant *User = dyn_cast<Constant>(*I); 436dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!User) { 43713fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner LastNonDeadUser = I; 43813fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner ++I; 43913fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner continue; 44013fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } 441a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 44213fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (!removeDeadUsersOfConstant(User)) { 44313fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner // If the constant wasn't dead, remember that this was the last live use 44413fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner // and move on to the next constant. 44513fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner LastNonDeadUser = I; 44613fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner ++I; 44713fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner continue; 44813fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } 449a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 45013fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner // If the constant was dead, then the iterator is invalidated. 45113fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (LastNonDeadUser == E) { 45236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines I = user_begin(); 45313fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner if (I == E) break; 45413fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } else { 45513fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner I = LastNonDeadUser; 45613fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner ++I; 45713fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } 45813fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner } 45913fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner} 46013fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner 46113fb0db0c26ec498cf8ffb0f9943d28962d4ced7Chris Lattner 4628638144825f43fe59b0e1b78d65d93f0a7b737a7Chris Lattner 463009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 4646b6f6ba66c656b205a6db0751685911032fe710eChris Lattner// ConstantInt 465009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 466009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 4672d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid ConstantInt::anchor() { } 4682d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 469db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstantInt::ConstantInt(IntegerType *Ty, const APInt& V) 470dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : Constant(Ty, ConstantIntVal, nullptr, 0), Val(V) { 471532d0ce208809545dc46d2de70c0384c036470d1Reid Spencer assert(V.getBitWidth() == Ty->getBitWidth() && "Invalid constant for type"); 472009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 473009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 474d01f50f42ce60207ed6d27fb1778e456d83be06cNick LewyckyConstantInt *ConstantInt::getTrue(LLVMContext &Context) { 4755defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson LLVMContextImpl *pImpl = Context.pImpl; 476f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer if (!pImpl->TheTrueVal) 477f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer pImpl->TheTrueVal = ConstantInt::get(Type::getInt1Ty(Context), 1); 478f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer return pImpl->TheTrueVal; 4795defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson} 4805defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson 481d01f50f42ce60207ed6d27fb1778e456d83be06cNick LewyckyConstantInt *ConstantInt::getFalse(LLVMContext &Context) { 4825defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson LLVMContextImpl *pImpl = Context.pImpl; 483f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer if (!pImpl->TheFalseVal) 484f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer pImpl->TheFalseVal = ConstantInt::get(Type::getInt1Ty(Context), 0); 485f601d6df6f43bb833461cbcee475c36998e6c259Benjamin Kramer return pImpl->TheFalseVal; 4865defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson} 4875defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson 488db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantInt::getTrue(Type *Ty) { 489db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *VTy = dyn_cast<VectorType>(Ty); 490d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky if (!VTy) { 491d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky assert(Ty->isIntegerTy(1) && "True must be i1 or vector of i1."); 492d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ConstantInt::getTrue(Ty->getContext()); 493d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky } 494d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky assert(VTy->getElementType()->isIntegerTy(1) && 495d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky "True must be vector of i1 or i1."); 4963c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), 4973c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner ConstantInt::getTrue(Ty->getContext())); 498d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky} 499d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky 500db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantInt::getFalse(Type *Ty) { 501db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *VTy = dyn_cast<VectorType>(Ty); 502d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky if (!VTy) { 503d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky assert(Ty->isIntegerTy(1) && "False must be i1 or vector of i1."); 504d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky return ConstantInt::getFalse(Ty->getContext()); 505d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky } 506d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky assert(VTy->getElementType()->isIntegerTy(1) && 507d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky "False must be vector of i1 or i1."); 5083c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), 5093c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner ConstantInt::getFalse(Ty->getContext())); 510d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky} 511d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky 5125defacc6e605f4651c6300237cef8e9bb2eb6d0eOwen Anderson 513eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// Get a ConstantInt from an APInt. Note that the value stored in the DenseMap 514eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// as the key, is a DenseMapAPIntKeyInfo::KeyTy which has provided the 515eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// operator== and operator!= to ensure that the DenseMap doesn't attempt to 516eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// compare APInt's of different widths, which would violate an APInt class 517eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// invariant which generates an assertion. 518d01f50f42ce60207ed6d27fb1778e456d83be06cNick LewyckyConstantInt *ConstantInt::get(LLVMContext &Context, const APInt &V) { 519eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Get the corresponding integer type for the bit width of the value. 520db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner IntegerType *ITy = IntegerType::get(Context, V.getBitWidth()); 521eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // get an existing value or the insertion position 5226dd56e60b002e5f3317bcc461be7fb8f6b19bbf5Benjamin Kramer LLVMContextImpl *pImpl = Context.pImpl; 5236dd56e60b002e5f3317bcc461be7fb8f6b19bbf5Benjamin Kramer ConstantInt *&Slot = pImpl->IntConstants[DenseMapAPIntKeyInfo::KeyTy(V, ITy)]; 52459d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson if (!Slot) Slot = new ConstantInt(ITy, V); 52559d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson return Slot; 526eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 527eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 528db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantInt::get(Type *Ty, uint64_t V, bool isSigned) { 529d01f50f42ce60207ed6d27fb1778e456d83be06cNick Lewycky Constant *C = get(cast<IntegerType>(Ty->getScalarType()), V, isSigned); 530eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 531eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // For vectors, broadcast the value. 532db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 5333c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), C); 534eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 535eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return C; 536eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 537eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 538a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstantInt *ConstantInt::get(IntegerType *Ty, uint64_t V, 539eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson bool isSigned) { 540eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return get(Ty->getContext(), APInt(Ty->getBitWidth(), V, isSigned)); 541eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 542eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 543a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstantInt *ConstantInt::getSigned(IntegerType *Ty, int64_t V) { 544eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return get(Ty, V, true); 545eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 546eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 547db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantInt::getSigned(Type *Ty, int64_t V) { 548eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return get(Ty, V, true); 549eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 550eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 551a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstant *ConstantInt::get(Type *Ty, const APInt& V) { 552eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantInt *C = get(Ty->getContext(), V); 553eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(C->getType() == Ty->getScalarType() && 554eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson "ConstantInt type doesn't match the type implied by its value!"); 555eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 556eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // For vectors, broadcast the value. 557db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 5583c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), C); 559eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 560eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return C; 561eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson} 562eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 563a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstantInt *ConstantInt::get(IntegerType* Ty, StringRef Str, 5640e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar uint8_t radix) { 5650e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar return get(Ty->getContext(), APInt(Ty->getBitWidth(), Str, radix)); 5660e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar} 5670e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 5686b6f6ba66c656b205a6db0751685911032fe710eChris Lattner//===----------------------------------------------------------------------===// 5699b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner// ConstantFP 5706b6f6ba66c656b205a6db0751685911032fe710eChris Lattner//===----------------------------------------------------------------------===// 5716b6f6ba66c656b205a6db0751685911032fe710eChris Lattner 572db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerstatic const fltSemantics *TypeToFloatSemantics(Type *Ty) { 573ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman if (Ty->isHalfTy()) 574ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return &APFloat::IEEEhalf; 575cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isFloatTy()) 57687d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola return &APFloat::IEEEsingle; 577cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isDoubleTy()) 57887d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola return &APFloat::IEEEdouble; 579cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner if (Ty->isX86_FP80Ty()) 58087d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola return &APFloat::x87DoubleExtended; 581cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner else if (Ty->isFP128Ty()) 58287d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola return &APFloat::IEEEquad; 583a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 584cf0fe8d813727383d630055bb9d1cde21b00b7e7Chris Lattner assert(Ty->isPPC_FP128Ty() && "Unknown FP format"); 58587d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola return &APFloat::PPCDoubleDouble; 58687d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola} 58787d1f47cb697bf05bf4a7c09b44ae6c893563d89Rafael Espindola 5882d24e2a396a1d211baaeedf32148a3b657240170David Blaikievoid ConstantFP::anchor() { } 5892d24e2a396a1d211baaeedf32148a3b657240170David Blaikie 5906f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson/// get() - This returns a constant fp for the specified value in the 5916f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson/// specified type. This should only be used for simple constant values like 5926f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson/// 2.0/1.0 etc, that are known-valid both as double and as the target format. 593a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstant *ConstantFP::get(Type *Ty, double V) { 5946f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson LLVMContext &Context = Ty->getContext(); 595a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 5966f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson APFloat FV(V); 5976f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson bool ignored; 5986f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson FV.convert(*TypeToFloatSemantics(Ty->getScalarType()), 5996f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson APFloat::rmNearestTiesToEven, &ignored); 6006f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson Constant *C = get(Context, FV); 6016f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 6026f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson // For vectors, broadcast the value. 603db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 6043c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), C); 6056f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 6066f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return C; 6076f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson} 6086f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 6090e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 610a78fa8cc2dd6d2ffe5e4fe605f38aae7b3d2fb7aChris LattnerConstant *ConstantFP::get(Type *Ty, StringRef Str) { 6110e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar LLVMContext &Context = Ty->getContext(); 6120e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 6130e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar APFloat FV(*TypeToFloatSemantics(Ty->getScalarType()), Str); 6140e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar Constant *C = get(Context, FV); 6150e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 6160e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar // For vectors, broadcast the value. 617db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 6183c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return ConstantVector::getSplat(VTy->getNumElements(), C); 6190e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 6200e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar return C; 6210e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar} 6220e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 62336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesConstant *ConstantFP::getNegativeZero(Type *Ty) { 62436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const fltSemantics &Semantics = *TypeToFloatSemantics(Ty->getScalarType()); 62536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines APFloat NegZero = APFloat::getZero(Semantics, /*Negative=*/true); 62636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *C = get(Ty->getContext(), NegZero); 6270e81f660dbb7c437a3c95427bb495eb18822e42cErick Tryzelaar 62836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 62936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ConstantVector::getSplat(VTy->getNumElements(), C); 63036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 63136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return C; 6326f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson} 6336f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 6346f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 6353c2c954e0baf4c5029f87277d75cc6ca38916f71Chris LattnerConstant *ConstantFP::getZeroValueForNegation(Type *Ty) { 63636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (Ty->isFPOrFPVectorTy()) 63736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return getNegativeZero(Ty); 6386f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 639a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return Constant::getNullValue(Ty); 6406f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson} 6416f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 6426f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 6436f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson// ConstantFP accessors. 6446f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen AndersonConstantFP* ConstantFP::get(LLVMContext &Context, const APFloat& V) { 6456f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson LLVMContextImpl* pImpl = Context.pImpl; 646a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 6476dd56e60b002e5f3317bcc461be7fb8f6b19bbf5Benjamin Kramer ConstantFP *&Slot = pImpl->FPConstants[DenseMapAPFloatKeyInfo::KeyTy(V)]; 648a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 6496f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson if (!Slot) { 650db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *Ty; 651ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman if (&V.getSemantics() == &APFloat::IEEEhalf) 652ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman Ty = Type::getHalfTy(Context); 653ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman else if (&V.getSemantics() == &APFloat::IEEEsingle) 65459d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Ty = Type::getFloatTy(Context); 65559d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson else if (&V.getSemantics() == &APFloat::IEEEdouble) 65659d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Ty = Type::getDoubleTy(Context); 65759d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson else if (&V.getSemantics() == &APFloat::x87DoubleExtended) 65859d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Ty = Type::getX86_FP80Ty(Context); 65959d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson else if (&V.getSemantics() == &APFloat::IEEEquad) 66059d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Ty = Type::getFP128Ty(Context); 66159d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson else { 66259d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson assert(&V.getSemantics() == &APFloat::PPCDoubleDouble && 66359d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson "Unknown FP format"); 66459d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Ty = Type::getPPC_FP128Ty(Context); 6656f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson } 66659d5aac0b435714f3ed2195dfa884aad2e993eb0Owen Anderson Slot = new ConstantFP(Ty, V); 6676f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson } 668a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 6696f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson return Slot; 6706f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson} 6716f83c9c6ef0e7f79825a0a8f22941815e4b684c7Owen Anderson 67236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesConstant *ConstantFP::getInfinity(Type *Ty, bool Negative) { 67336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const fltSemantics &Semantics = *TypeToFloatSemantics(Ty->getScalarType()); 67436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines Constant *C = get(Ty->getContext(), APFloat::getInf(Semantics, Negative)); 67536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 67636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (VectorType *VTy = dyn_cast<VectorType>(Ty)) 67736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return ConstantVector::getSplat(VTy->getNumElements(), C); 67836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 67936b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return C; 680f344f7f008b69ea1e711c2cf80be9e660e40ee13Dan Gohman} 681f344f7f008b69ea1e711c2cf80be9e660e40ee13Dan Gohman 682db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstantFP::ConstantFP(Type *Ty, const APFloat& V) 683dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines : Constant(Ty, ConstantFPVal, nullptr, 0), Val(V) { 684288e78fbe7704d01bace67df88002f33c82e7ab5Chris Lattner assert(&V.getSemantics() == TypeToFloatSemantics(Ty) && 685288e78fbe7704d01bace67df88002f33c82e7ab5Chris Lattner "FP type Mismatch"); 686009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 687009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 688032c6eb1c4d36a9e906f5efc0ada76c952225a4fChris Lattnerbool ConstantFP::isExactlyValue(const APFloat &V) const { 689f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen return Val.bitwiseIsEqual(V); 6909b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner} 6919b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner 6929b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner//===----------------------------------------------------------------------===// 693ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner// ConstantAggregateZero Implementation 694ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner//===----------------------------------------------------------------------===// 695ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 696ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getSequentialElement - If this CAZ has array or vector type, return a zero 697ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// with the right element type. 6983d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *ConstantAggregateZero::getSequentialElement() const { 699230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return Constant::getNullValue(getType()->getSequentialElementType()); 700ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 701ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 702ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getStructElement - If this CAZ has struct type, return a zero with the 703ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// right element type for the specified element. 7043d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *ConstantAggregateZero::getStructElement(unsigned Elt) const { 705230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return Constant::getNullValue(getType()->getStructElementType(Elt)); 706ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 707ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 708ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getElementValue - Return a zero of the right value for the specified GEP 709ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// index if we can, otherwise return null (e.g. if C is a ConstantExpr). 7103d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *ConstantAggregateZero::getElementValue(Constant *C) const { 711ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner if (isa<SequentialType>(getType())) 712ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner return getSequentialElement(); 713ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner return getStructElement(cast<ConstantInt>(C)->getZExtValue()); 714ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 715ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 716df39028607ca751f0a3f50a76144464b825ff97aChris Lattner/// getElementValue - Return a zero of the right value for the specified GEP 717df39028607ca751f0a3f50a76144464b825ff97aChris Lattner/// index. 7183d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerConstant *ConstantAggregateZero::getElementValue(unsigned Idx) const { 719df39028607ca751f0a3f50a76144464b825ff97aChris Lattner if (isa<SequentialType>(getType())) 720df39028607ca751f0a3f50a76144464b825ff97aChris Lattner return getSequentialElement(); 721df39028607ca751f0a3f50a76144464b825ff97aChris Lattner return getStructElement(Idx); 722df39028607ca751f0a3f50a76144464b825ff97aChris Lattner} 723df39028607ca751f0a3f50a76144464b825ff97aChris Lattner 724df39028607ca751f0a3f50a76144464b825ff97aChris Lattner 725ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner//===----------------------------------------------------------------------===// 726ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner// UndefValue Implementation 727ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner//===----------------------------------------------------------------------===// 728ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 729ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getSequentialElement - If this undef has array or vector type, return an 730ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// undef with the right element type. 7313d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerUndefValue *UndefValue::getSequentialElement() const { 732230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return UndefValue::get(getType()->getSequentialElementType()); 733ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 734ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 735ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getStructElement - If this undef has struct type, return a zero with the 736ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// right element type for the specified element. 7373d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerUndefValue *UndefValue::getStructElement(unsigned Elt) const { 738230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return UndefValue::get(getType()->getStructElementType(Elt)); 739ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 740ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 741ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// getElementValue - Return an undef of the right value for the specified GEP 742ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// index if we can, otherwise return null (e.g. if C is a ConstantExpr). 7433d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerUndefValue *UndefValue::getElementValue(Constant *C) const { 744ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner if (isa<SequentialType>(getType())) 745ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner return getSequentialElement(); 746ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner return getStructElement(cast<ConstantInt>(C)->getZExtValue()); 747ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner} 748ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 749df39028607ca751f0a3f50a76144464b825ff97aChris Lattner/// getElementValue - Return an undef of the right value for the specified GEP 750df39028607ca751f0a3f50a76144464b825ff97aChris Lattner/// index. 7513d5ed2250e78c3e849232398cb550238155dbb72Chris LattnerUndefValue *UndefValue::getElementValue(unsigned Idx) const { 752df39028607ca751f0a3f50a76144464b825ff97aChris Lattner if (isa<SequentialType>(getType())) 753df39028607ca751f0a3f50a76144464b825ff97aChris Lattner return getSequentialElement(); 754df39028607ca751f0a3f50a76144464b825ff97aChris Lattner return getStructElement(Idx); 755df39028607ca751f0a3f50a76144464b825ff97aChris Lattner} 756df39028607ca751f0a3f50a76144464b825ff97aChris Lattner 757df39028607ca751f0a3f50a76144464b825ff97aChris Lattner 758ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 759ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner//===----------------------------------------------------------------------===// 7609b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner// ConstantXXX Classes 7619b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner//===----------------------------------------------------------------------===// 7629b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner 76318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattnertemplate <typename ItTy, typename EltTy> 76418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattnerstatic bool rangeOnlyContains(ItTy Start, ItTy End, EltTy Elt) { 76518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (; Start != End; ++Start) 76618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (*Start != Elt) 76718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return false; 76818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return true; 76918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner} 7709b4ee0c1bdbd46ea9b2bb5fd68edcb23ce0a4a8dChris Lattner 771166579e287a38d907acafc24243146e9f3ee9799Jay FoadConstantArray::ConstantArray(ArrayType *T, ArrayRef<Constant *> V) 772efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif : Constant(T, ConstantArrayVal, 773efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif OperandTraits<ConstantArray>::op_end(this) - V.size(), 774efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif V.size()) { 775e0de1d64be1a20c7b617d99e11bacbb0325f5bb6Alkis Evlogimenos assert(V.size() == T->getNumElements() && 776e0de1d64be1a20c7b617d99e11bacbb0325f5bb6Alkis Evlogimenos "Invalid initializer vector for constant array"); 777166579e287a38d907acafc24243146e9f3ee9799Jay Foad for (unsigned i = 0, e = V.size(); i != e; ++i) 778166579e287a38d907acafc24243146e9f3ee9799Jay Foad assert(V[i]->getType() == T->getElementType() && 779cad90ad162daf81c0d8e45b856bb9152abea4db3Alkis Evlogimenos "Initializer for array element doesn't match array element type!"); 780166579e287a38d907acafc24243146e9f3ee9799Jay Foad std::copy(V.begin(), V.end(), op_begin()); 781009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 782009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 783db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantArray::get(ArrayType *Ty, ArrayRef<Constant*> V) { 78418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // Empty arrays are canonicalized to ConstantAggregateZero. 78518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (V.empty()) 78618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantAggregateZero::get(Ty); 78718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner 7881fb613c43de4dc6d6955be6054a7300de8f2d79bJeffrey Yasskin for (unsigned i = 0, e = V.size(); i != e; ++i) { 7891fb613c43de4dc6d6955be6054a7300de8f2d79bJeffrey Yasskin assert(V[i]->getType() == Ty->getElementType() && 7901fb613c43de4dc6d6955be6054a7300de8f2d79bJeffrey Yasskin "Wrong type in array element initializer"); 7911fb613c43de4dc6d6955be6054a7300de8f2d79bJeffrey Yasskin } 7921fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson LLVMContextImpl *pImpl = Ty->getContext().pImpl; 793a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 79418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // If this is an all-zero array, return a ConstantAggregateZero object. If 79518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // all undef, return an UndefValue, if "all simple", then return a 79618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // ConstantDataArray. 79718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Constant *C = V[0]; 79818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (isa<UndefValue>(C) && rangeOnlyContains(V.begin(), V.end(), C)) 79991766fe066efe6e0969ba805a2e3726a70ed34a3Argyrios Kyrtzidis return UndefValue::get(Ty); 8003ef9cfef13d7c7208b98b2d9995c3df6dcfe0d99Chris Lattner 80118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (C->isNullValue() && rangeOnlyContains(V.begin(), V.end(), C)) 80218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantAggregateZero::get(Ty); 8033ef9cfef13d7c7208b98b2d9995c3df6dcfe0d99Chris Lattner 80418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // Check to see if all of the elements are ConstantFP or ConstantInt and if 80518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // the element type is compatible with ConstantDataVector. If so, use it. 80618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantDataSequential::isElementTypeCompatible(C->getType())) { 80718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // We speculatively build the elements here even if it turns out that there 80818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // is a constantexpr or something else weird in the array, since it is so 80918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // uncommon for that to happen. 81018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) { 81118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (CI->getType()->isIntegerTy(8)) { 81218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<uint8_t, 16> Elts; 81318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 81418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 81518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CI->getZExtValue()); 81618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 81718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 81818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 81918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 82018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } else if (CI->getType()->isIntegerTy(16)) { 82118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<uint16_t, 16> Elts; 82218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 82318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 82418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CI->getZExtValue()); 82518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 82618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 82718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 82818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 82918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } else if (CI->getType()->isIntegerTy(32)) { 83018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<uint32_t, 16> Elts; 83118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 83218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 83318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CI->getZExtValue()); 83418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 83518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 83618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 83718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 83818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } else if (CI->getType()->isIntegerTy(64)) { 83918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<uint64_t, 16> Elts; 84018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 84118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 84218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CI->getZExtValue()); 84318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 84418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 84518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 84618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 84718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } 84818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } 849a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 85018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 85118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (CFP->getType()->isFloatTy()) { 85218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<float, 16> Elts; 85318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 85418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) 85518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CFP->getValueAPF().convertToFloat()); 85618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 85718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 85818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 85918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 86018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } else if (CFP->getType()->isDoubleTy()) { 86118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner SmallVector<double, 16> Elts; 86218c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 86318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) 86418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner Elts.push_back(CFP->getValueAPF().convertToDouble()); 86518c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner else 86618c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner break; 86718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (Elts.size() == V.size()) 86818c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return ConstantDataArray::get(C->getContext(), Elts); 86918c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } 87018c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } 87118c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner } 87291766fe066efe6e0969ba805a2e3726a70ed34a3Argyrios Kyrtzidis 87318c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner // Otherwise, we really do want to create a ConstantArray. 87418c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner return pImpl->ArrayConstants.getOrCreate(Ty, V); 8751fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson} 8761fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson 877b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner/// getTypeForElements - Return an anonymous struct type to use for a constant 878b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner/// with the specified set of elements. The list must not be empty. 879b065b06c12dba6001b8140df2744d0c856ef6ea1Chris LattnerStructType *ConstantStruct::getTypeForElements(LLVMContext &Context, 880b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner ArrayRef<Constant*> V, 881b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner bool Packed) { 882a7a3f04eb9a18c11940ab1486709c63c8bd296ffBill Wendling unsigned VecSize = V.size(); 883a7a3f04eb9a18c11940ab1486709c63c8bd296ffBill Wendling SmallVector<Type*, 16> EltTypes(VecSize); 884a7a3f04eb9a18c11940ab1486709c63c8bd296ffBill Wendling for (unsigned i = 0; i != VecSize; ++i) 885a7a3f04eb9a18c11940ab1486709c63c8bd296ffBill Wendling EltTypes[i] = V[i]->getType(); 886a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 887b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner return StructType::get(Context, EltTypes, Packed); 888b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner} 889b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner 890b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner 891b065b06c12dba6001b8140df2744d0c856ef6ea1Chris LattnerStructType *ConstantStruct::getTypeForElements(ArrayRef<Constant*> V, 892b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner bool Packed) { 893b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner assert(!V.empty() && 894b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner "ConstantStruct::getTypeForElements cannot be called on empty list"); 895b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner return getTypeForElements(V[0]->getContext(), V, Packed); 896b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner} 897b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner 898b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner 899166579e287a38d907acafc24243146e9f3ee9799Jay FoadConstantStruct::ConstantStruct(StructType *T, ArrayRef<Constant *> V) 900efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif : Constant(T, ConstantStructVal, 901efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif OperandTraits<ConstantStruct>::op_end(this) - V.size(), 902efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif V.size()) { 903f4ef8db7cd71edabe424f9d5c7d3ee23ef9924d5Chris Lattner assert(V.size() == T->getNumElements() && 904345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve "Invalid initializer vector for constant structure"); 905166579e287a38d907acafc24243146e9f3ee9799Jay Foad for (unsigned i = 0, e = V.size(); i != e; ++i) 906166579e287a38d907acafc24243146e9f3ee9799Jay Foad assert((T->isOpaque() || V[i]->getType() == T->getElementType(i)) && 907b84388937cbe7d5cb32a39e649ef020d4d7e5cb5Chris Lattner "Initializer for struct element doesn't match struct element type!"); 908166579e287a38d907acafc24243146e9f3ee9799Jay Foad std::copy(V.begin(), V.end(), op_begin()); 909009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 910009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 9118fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson// ConstantStruct accessors. 912db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantStruct::get(StructType *ST, ArrayRef<Constant*> V) { 9131afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner assert((ST->isOpaque() || ST->getNumElements() == V.size()) && 9141afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner "Incorrect # elements specified to ConstantStruct::get"); 915e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner 916e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner // Create a ConstantAggregateZero value if all elements are zeros. 917e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner bool isZero = true; 918e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner bool isUndef = false; 919e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner 920e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (!V.empty()) { 921e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner isUndef = isa<UndefValue>(V[0]); 922e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner isZero = V[0]->isNullValue(); 923e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (isUndef || isZero) { 924e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) { 925e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (!V[i]->isNullValue()) 926e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner isZero = false; 927e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (!isa<UndefValue>(V[i])) 928e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner isUndef = false; 929e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } 930e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } 931a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova } 932e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (isZero) 933e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner return ConstantAggregateZero::get(ST); 934e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (isUndef) 935e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner return UndefValue::get(ST); 936a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 937e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner return ST->getContext().pImpl->StructConstants.getOrCreate(ST, V); 9388fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson} 939e467147b30a10f2687a8ed9c8895a8eb846b50bbChris Lattner 940f4ef8db7cd71edabe424f9d5c7d3ee23ef9924d5Chris LattnerConstant *ConstantStruct::get(StructType *T, ...) { 94141ee4e57ea0f2afb89fd136065edb03f32f972d3Talin va_list ap; 942b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner SmallVector<Constant*, 8> Values; 943b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner va_start(ap, T); 944b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner while (Constant *Val = va_arg(ap, llvm::Constant*)) 94541ee4e57ea0f2afb89fd136065edb03f32f972d3Talin Values.push_back(Val); 946bdcd766028bc17e83f1312e3e52b1d9b22c6a624Talin va_end(ap); 947b065b06c12dba6001b8140df2744d0c856ef6ea1Chris Lattner return get(T, Values); 94841ee4e57ea0f2afb89fd136065edb03f32f972d3Talin} 94941ee4e57ea0f2afb89fd136065edb03f32f972d3Talin 950166579e287a38d907acafc24243146e9f3ee9799Jay FoadConstantVector::ConstantVector(VectorType *T, ArrayRef<Constant *> V) 951efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif : Constant(T, ConstantVectorVal, 952efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif OperandTraits<ConstantVector>::op_end(this) - V.size(), 953efe65369a74871c3140a540a6c95ce5d1f080954Gabor Greif V.size()) { 954166579e287a38d907acafc24243146e9f3ee9799Jay Foad for (size_t i = 0, e = V.size(); i != e; i++) 955166579e287a38d907acafc24243146e9f3ee9799Jay Foad assert(V[i]->getType() == T->getElementType() && 956fa73ea2d9fd785a214256ca44488407b26c5a3dbDan Gohman "Initializer for vector element doesn't match vector element type!"); 957166579e287a38d907acafc24243146e9f3ee9799Jay Foad std::copy(V.begin(), V.end(), op_begin()); 958715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke} 959715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke 960af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson// ConstantVector accessors. 961a0c138429e101f573d43740322245c1d5b8b04a0Jay FoadConstant *ConstantVector::get(ArrayRef<Constant*> V) { 9629afc527671618e6cd878c29f5a3ac63598486994Jay Foad assert(!V.empty() && "Vectors can't be empty"); 963db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner VectorType *T = VectorType::get(V.front()->getType(), V.size()); 9642ca5c8644e6c35b3a7910a576ed89cddb7b82c3bChris Lattner LLVMContextImpl *pImpl = T->getContext().pImpl; 9659afc527671618e6cd878c29f5a3ac63598486994Jay Foad 9662ca5c8644e6c35b3a7910a576ed89cddb7b82c3bChris Lattner // If this is an all-undef or all-zero vector, return a 967af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson // ConstantAggregateZero or UndefValue. 968af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson Constant *C = V[0]; 969af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson bool isZero = C->isNullValue(); 970af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson bool isUndef = isa<UndefValue>(C); 971af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson 972af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson if (isZero || isUndef) { 973af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson for (unsigned i = 1, e = V.size(); i != e; ++i) 974af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson if (V[i] != C) { 975af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson isZero = isUndef = false; 976af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson break; 977af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson } 978af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson } 979a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 980af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson if (isZero) 9819e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson return ConstantAggregateZero::get(T); 982af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson if (isUndef) 9839e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson return UndefValue::get(T); 984a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 98536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // Check to see if all of the elements are ConstantFP or ConstantInt and if 98636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // the element type is compatible with ConstantDataVector. If so, use it. 98718c7f80b3e83ab584bd8572695a3cde8bafd9d3cChris Lattner if (ConstantDataSequential::isElementTypeCompatible(C->getType())) { 98836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // We speculatively build the elements here even if it turns out that there 98936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // is a constantexpr or something else weird in the array, since it is so 99036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // uncommon for that to happen. 99136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(C)) { 99236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (CI->getType()->isIntegerTy(8)) { 99336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<uint8_t, 16> Elts; 99436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 99536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 99636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CI->getZExtValue()); 99736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 99836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 99936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 100036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 100136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } else if (CI->getType()->isIntegerTy(16)) { 100236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<uint16_t, 16> Elts; 100336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 100436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 100536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CI->getZExtValue()); 100636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 100736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 100836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 100936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 101036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } else if (CI->getType()->isIntegerTy(32)) { 101136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<uint32_t, 16> Elts; 101236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 101336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 101436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CI->getZExtValue()); 101536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 101636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 101736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 101836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 101936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } else if (CI->getType()->isIntegerTy(64)) { 102036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<uint64_t, 16> Elts; 102136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 102236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V[i])) 102336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CI->getZExtValue()); 102436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 102536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 102636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 102736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 102836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 102936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 1030a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 103136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(C)) { 103236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (CFP->getType()->isFloatTy()) { 103336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<float, 16> Elts; 103436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 103536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) 103636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CFP->getValueAPF().convertToFloat()); 103736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 103836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 103936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 104036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 104136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } else if (CFP->getType()->isDoubleTy()) { 104236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<double, 16> Elts; 104336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner for (unsigned i = 0, e = V.size(); i != e; ++i) 104436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(V[i])) 104536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner Elts.push_back(CFP->getValueAPF().convertToDouble()); 104636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner else 104736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner break; 104836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (Elts.size() == V.size()) 104936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::get(C->getContext(), Elts); 105036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 105136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 105236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 1053a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 105436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // Otherwise, the element type isn't compatible with ConstantDataVector, or 105536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // the operand list constants a ConstantExpr or something else strange. 1056af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson return pImpl->VectorConstants.getOrCreate(T, V); 1057af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson} 1058af7ec975870f92245f1f1484ac80a1e2db6a0afaOwen Anderson 10593c2c954e0baf4c5029f87277d75cc6ca38916f71Chris LattnerConstant *ConstantVector::getSplat(unsigned NumElts, Constant *V) { 106036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // If this splat is compatible with ConstantDataVector, use it instead of 106136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner // ConstantVector. 106236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if ((isa<ConstantFP>(V) || isa<ConstantInt>(V)) && 106336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner ConstantDataSequential::isElementTypeCompatible(V->getType())) 106436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantDataVector::getSplat(NumElts, V); 1065a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 10663c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner SmallVector<Constant*, 32> Elts(NumElts, V); 10673c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return get(Elts); 10683c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner} 10693c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner 10703c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner 10713da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer// Utility function for determining if a ConstantExpr is a CastOp or not. This 10723da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer// can't be inline because we don't want to #include Instruction.h into 10733da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer// Constant.h 10743da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencerbool ConstantExpr::isCast() const { 10753da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer return Instruction::isCast(getOpcode()); 10763da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 10773da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1078077d0eb1bd54b71143139a5184d291454d638ebcReid Spencerbool ConstantExpr::isCompare() const { 10797f6aa2b162e5daaf7b9ccf05d749597d3d7cf460Nick Lewycky return getOpcode() == Instruction::ICmp || getOpcode() == Instruction::FCmp; 1080077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer} 1081077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1082e6992f728a94654e43269580a10a667f18dadba9Dan Gohmanbool ConstantExpr::isGEPWithNoNotionalOverIndexing() const { 1083e6992f728a94654e43269580a10a667f18dadba9Dan Gohman if (getOpcode() != Instruction::GetElementPtr) return false; 1084e6992f728a94654e43269580a10a667f18dadba9Dan Gohman 1085e6992f728a94654e43269580a10a667f18dadba9Dan Gohman gep_type_iterator GEPI = gep_type_begin(this), E = gep_type_end(this); 108636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines User::const_op_iterator OI = std::next(this->op_begin()); 1087e6992f728a94654e43269580a10a667f18dadba9Dan Gohman 1088e6992f728a94654e43269580a10a667f18dadba9Dan Gohman // Skip the first index, as it has no static limit. 1089e6992f728a94654e43269580a10a667f18dadba9Dan Gohman ++GEPI; 1090e6992f728a94654e43269580a10a667f18dadba9Dan Gohman ++OI; 1091e6992f728a94654e43269580a10a667f18dadba9Dan Gohman 1092e6992f728a94654e43269580a10a667f18dadba9Dan Gohman // The remaining indices must be compile-time known integers within the 1093e6992f728a94654e43269580a10a667f18dadba9Dan Gohman // bounds of the corresponding notional static array types. 1094e6992f728a94654e43269580a10a667f18dadba9Dan Gohman for (; GEPI != E; ++GEPI, ++OI) { 1095e6992f728a94654e43269580a10a667f18dadba9Dan Gohman ConstantInt *CI = dyn_cast<ConstantInt>(*OI); 1096e6992f728a94654e43269580a10a667f18dadba9Dan Gohman if (!CI) return false; 1097db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (ArrayType *ATy = dyn_cast<ArrayType>(*GEPI)) 1098e6992f728a94654e43269580a10a667f18dadba9Dan Gohman if (CI->getValue().getActiveBits() > 64 || 1099e6992f728a94654e43269580a10a667f18dadba9Dan Gohman CI->getZExtValue() >= ATy->getNumElements()) 1100e6992f728a94654e43269580a10a667f18dadba9Dan Gohman return false; 1101e6992f728a94654e43269580a10a667f18dadba9Dan Gohman } 1102e6992f728a94654e43269580a10a667f18dadba9Dan Gohman 1103e6992f728a94654e43269580a10a667f18dadba9Dan Gohman // All the indices checked out. 1104e6992f728a94654e43269580a10a667f18dadba9Dan Gohman return true; 1105e6992f728a94654e43269580a10a667f18dadba9Dan Gohman} 1106e6992f728a94654e43269580a10a667f18dadba9Dan Gohman 110781a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohmanbool ConstantExpr::hasIndices() const { 110881a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman return getOpcode() == Instruction::ExtractValue || 110981a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman getOpcode() == Instruction::InsertValue; 111081a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman} 111181a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman 1112d30aa5a1edac5256573e8d76dd155df3d3fdec84Jay FoadArrayRef<unsigned> ConstantExpr::getIndices() const { 111381a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman if (const ExtractValueConstantExpr *EVCE = 111481a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman dyn_cast<ExtractValueConstantExpr>(this)) 111581a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman return EVCE->Indices; 11161a203571ca94c4770a8cada8ace7fbeb0e65799aDan Gohman 11171a203571ca94c4770a8cada8ace7fbeb0e65799aDan Gohman return cast<InsertValueConstantExpr>(this)->Indices; 111881a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman} 111981a0c0b44e582baca8b68754a7fcabfc3aef2e7aDan Gohman 1120728b6db6fbd3caee7fa25b377f4592160476bb9cReid Spencerunsigned ConstantExpr::getPredicate() const { 11213e19473af308325801fbdd27abc56c8afcfde2cbChris Lattner assert(isCompare()); 1122b7daa84a3500105a9e5245b463155fcb15ed6730Chris Lattner return ((const CompareConstantExpr*)this)->predicate; 1123728b6db6fbd3caee7fa25b377f4592160476bb9cReid Spencer} 1124f4ba6c710c298fe9b492b9cde82ce5efd46afd5dChris Lattner 11251fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner/// getWithOperandReplaced - Return a constant expression identical to this 11261fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner/// one, but with the specified operand set to the specified value. 11273da59db637a887474c1b1346c1f3ccf53b6c4663Reid SpencerConstant * 11283da59db637a887474c1b1346c1f3ccf53b6c4663Reid SpencerConstantExpr::getWithOperandReplaced(unsigned OpNo, Constant *Op) const { 11291fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner assert(Op->getType() == getOperand(OpNo)->getType() && 11301fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner "Replacing operand with value of different type!"); 1131b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner if (getOperand(OpNo) == Op) 1132b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return const_cast<ConstantExpr*>(this); 11331a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner 11341a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner SmallVector<Constant*, 8> NewOps; 11351a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 11361a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner NewOps.push_back(i == OpNo ? Op : getOperand(i)); 1137a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 11381a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner return getWithOperands(NewOps); 1139b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner} 1140b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner 1141b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner/// getWithOperands - This returns the current constant expression with the 11421afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// operands replaced with the specified values. The specified array must 11431afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner/// have the same number of operands as our current one. 1144b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris LattnerConstant *ConstantExpr:: 1145db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnergetWithOperands(ArrayRef<Constant*> Ops, Type *Ty) const { 1146b81e457eb02b67a9ef5fb9edc1604b177acb821dJay Foad assert(Ops.size() == getNumOperands() && "Operand count mismatch!"); 11471afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner bool AnyChange = Ty != getType(); 11481afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner for (unsigned i = 0; i != Ops.size(); ++i) 1149b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner AnyChange |= Ops[i] != getOperand(i); 1150a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1151b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner if (!AnyChange) // No operands changed, return self. 1152b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return const_cast<ConstantExpr*>(this); 1153b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner 1154b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner switch (getOpcode()) { 11553da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::Trunc: 11563da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::ZExt: 11573da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::SExt: 11583da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::FPTrunc: 11593da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::FPExt: 11603da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::UIToFP: 11613da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::SIToFP: 11623da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::FPToUI: 11633da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::FPToSI: 11643da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::PtrToInt: 11653da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::IntToPtr: 11663da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer case Instruction::BitCast: 116759d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case Instruction::AddrSpaceCast: 11681afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner return ConstantExpr::getCast(getOpcode(), Ops[0], Ty); 11691fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner case Instruction::Select: 1170b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return ConstantExpr::getSelect(Ops[0], Ops[1], Ops[2]); 11711fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner case Instruction::InsertElement: 1172b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return ConstantExpr::getInsertElement(Ops[0], Ops[1], Ops[2]); 11731fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner case Instruction::ExtractElement: 1174b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return ConstantExpr::getExtractElement(Ops[0], Ops[1]); 11751a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner case Instruction::InsertValue: 11761a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner return ConstantExpr::getInsertValue(Ops[0], Ops[1], getIndices()); 11771a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner case Instruction::ExtractValue: 11781a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner return ConstantExpr::getExtractValue(Ops[0], getIndices()); 11791fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner case Instruction::ShuffleVector: 1180b88a7fbdf6365a6d7a4ad334b8411462ae851924Chris Lattner return ConstantExpr::getShuffleVector(Ops[0], Ops[1], Ops[2]); 1181f9021ff7407d3e979a15acc1e21da3e39e423936Chris Lattner case Instruction::GetElementPtr: 11821a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner return ConstantExpr::getGetElementPtr(Ops[0], Ops.slice(1), 11831a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner cast<GEPOperator>(this)->isInBounds()); 1184e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case Instruction::ICmp: 1185e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer case Instruction::FCmp: 1186e4d87aa2de6e52952dca73716386db09aad5a8fdReid Spencer return ConstantExpr::getCompare(getPredicate(), Ops[0], Ops[1]); 11871fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner default: 11881fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner assert(getNumOperands() == 2 && "Must be binary operator?"); 1189cafe9bba32aeed16e8e3db28b4cd4ff13160438fChris Lattner return ConstantExpr::get(getOpcode(), Ops[0], Ops[1], SubclassOptionalData); 11901fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner } 11911fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner} 11921fe8f6bcef83844cf040299a0d92e497fd752806Chris Lattner 1193009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1194009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner//===----------------------------------------------------------------------===// 1195009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner// isValueValidForType implementations 1196009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1197db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerbool ConstantInt::isValueValidForType(Type *Ty, uint64_t Val) { 1198230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner unsigned NumBits = Ty->getIntegerBitWidth(); // assert okay 1199230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (Ty->isIntegerTy(1)) 1200a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Val == 0 || Val == 1; 1201554cec6e65fecdf3a14b3ddd1cb2c9615e726220Reid Spencer if (NumBits >= 64) 1202a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return true; // always true, has to fit in largest type 1203a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer uint64_t Max = (1ll << NumBits) - 1; 1204a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return Val <= Max; 12059b11d518aef8e191e5e94f3503dfddbe1c0a387aReid Spencer} 12069b11d518aef8e191e5e94f3503dfddbe1c0a387aReid Spencer 1207db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerbool ConstantInt::isValueValidForType(Type *Ty, int64_t Val) { 1208230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner unsigned NumBits = Ty->getIntegerBitWidth(); 1209230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner if (Ty->isIntegerTy(1)) 1210c10305743c313558405079452138f03124e87581Reid Spencer return Val == 0 || Val == 1 || Val == -1; 1211554cec6e65fecdf3a14b3ddd1cb2c9615e726220Reid Spencer if (NumBits >= 64) 1212a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return true; // always true, has to fit in largest type 1213a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer int64_t Min = -(1ll << (NumBits-1)); 1214a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer int64_t Max = (1ll << (NumBits-1)) - 1; 1215a54b7cbd452b3adb2f51346140d996b29c2cdb30Reid Spencer return (Val >= Min && Val <= Max); 1216009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner} 1217009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1218db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattnerbool ConstantFP::isValueValidForType(Type *Ty, const APFloat& Val) { 1219f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen // convert modifies in place, so make a copy. 1220f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen APFloat Val2 = APFloat(Val); 122123a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen bool losesInfo; 1222f70c22b019494723d0e706f93d6542dfaa6e73a5Chris Lattner switch (Ty->getTypeID()) { 1223009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner default: 1224009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner return false; // These can't be represented as floating point! 1225009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner 1226f04afdbb48568ef09f11fd10ac03426101f2dbf8Dale Johannesen // FIXME rounding mode needs to be more flexible 1227ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman case Type::HalfTyID: { 1228ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman if (&Val2.getSemantics() == &APFloat::IEEEhalf) 1229ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return true; 1230ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman Val2.convert(APFloat::IEEEhalf, APFloat::rmNearestTiesToEven, &losesInfo); 1231ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return !losesInfo; 1232ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman } 123323a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen case Type::FloatTyID: { 123423a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen if (&Val2.getSemantics() == &APFloat::IEEEsingle) 123523a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen return true; 123623a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen Val2.convert(APFloat::IEEEsingle, APFloat::rmNearestTiesToEven, &losesInfo); 123723a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen return !losesInfo; 123823a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen } 123923a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen case Type::DoubleTyID: { 1240ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman if (&Val2.getSemantics() == &APFloat::IEEEhalf || 1241ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman &Val2.getSemantics() == &APFloat::IEEEsingle || 124223a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen &Val2.getSemantics() == &APFloat::IEEEdouble) 124323a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen return true; 124423a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen Val2.convert(APFloat::IEEEdouble, APFloat::rmNearestTiesToEven, &losesInfo); 124523a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen return !losesInfo; 124623a98551ab65eeb8fe5019df8b7db4891582a4bdDale Johannesen } 1247ebbc95da49c6f4ae09947a9f4ab6a8616ea40e3bDale Johannesen case Type::X86_FP80TyID: 1248ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return &Val2.getSemantics() == &APFloat::IEEEhalf || 1249ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman &Val2.getSemantics() == &APFloat::IEEEsingle || 12509d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen &Val2.getSemantics() == &APFloat::IEEEdouble || 12519d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen &Val2.getSemantics() == &APFloat::x87DoubleExtended; 1252ebbc95da49c6f4ae09947a9f4ab6a8616ea40e3bDale Johannesen case Type::FP128TyID: 1253ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return &Val2.getSemantics() == &APFloat::IEEEhalf || 1254ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman &Val2.getSemantics() == &APFloat::IEEEsingle || 12559d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen &Val2.getSemantics() == &APFloat::IEEEdouble || 12569d5f45607793052bf5b4436d1b43013fab9999acDale Johannesen &Val2.getSemantics() == &APFloat::IEEEquad; 1257a471c2ecda37cd1bae0d94e832f002caa7b63216Dale Johannesen case Type::PPC_FP128TyID: 1258ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman return &Val2.getSemantics() == &APFloat::IEEEhalf || 1259ce16339930a2b03e53b4e6399ef59c092a7f2cfaDan Gohman &Val2.getSemantics() == &APFloat::IEEEsingle || 1260a471c2ecda37cd1bae0d94e832f002caa7b63216Dale Johannesen &Val2.getSemantics() == &APFloat::IEEEdouble || 1261a471c2ecda37cd1bae0d94e832f002caa7b63216Dale Johannesen &Val2.getSemantics() == &APFloat::PPCDoubleDouble; 1262009505452b713ed2e3a8e99c5545a6e721c65495Chris Lattner } 1263d74ea2bbd8bb630331f35ead42d385249bd42af8Chris Lattner} 126437bf6308ab839cfc85cc864b99d3e35651b66d94Chris Lattner 1265ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 1266531daef1542fd6a958c509ccbb6390d33496aae9Chris Lattner//===----------------------------------------------------------------------===// 1267531daef1542fd6a958c509ccbb6390d33496aae9Chris Lattner// Factory Function Implementation 1268531daef1542fd6a958c509ccbb6390d33496aae9Chris Lattner 12699df0fb4e8176325d713ba4eb67791e36cb833432Chris LattnerConstantAggregateZero *ConstantAggregateZero::get(Type *Ty) { 127061c70e98ac3c7504d31dd9bc81c4e9cb998e9984Chris Lattner assert((Ty->isStructTy() || Ty->isArrayTy() || Ty->isVectorTy()) && 12719e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson "Cannot create an aggregate zero of non-aggregate type!"); 12729e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson 12739df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner ConstantAggregateZero *&Entry = Ty->getContext().pImpl->CAZConstants[Ty]; 1274dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!Entry) 12759df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner Entry = new ConstantAggregateZero(Ty); 1276a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 12779df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner return Entry; 12789e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson} 12799e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson 1280ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// destroyConstant - Remove the constant from the constant table. 12810f8b53f19d29013ab18f3d444cea1e6305405611Dan Gohman/// 128204fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantAggregateZero::destroyConstant() { 12839df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner getContext().pImpl->CAZConstants.erase(getType()); 128440bbeb5d077b1bc2b933d8c8628024dfa9b428c3Chris Lattner destroyConstantImpl(); 128540bbeb5d077b1bc2b933d8c8628024dfa9b428c3Chris Lattner} 128640bbeb5d077b1bc2b933d8c8628024dfa9b428c3Chris Lattner 12870f8b53f19d29013ab18f3d444cea1e6305405611Dan Gohman/// destroyConstant - Remove the constant from the constant table... 12880f8b53f19d29013ab18f3d444cea1e6305405611Dan Gohman/// 128904fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantArray::destroyConstant() { 12901afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner getType()->getContext().pImpl->ArrayConstants.remove(this); 129102ec5ede6cf10163086a27241508fc5778e39737Chris Lattner destroyConstantImpl(); 129202ec5ede6cf10163086a27241508fc5778e39737Chris Lattner} 129302ec5ede6cf10163086a27241508fc5778e39737Chris Lattner 129493aeea3748b11fa213b345edf3c86275a4936a31Chris Lattner 1295e9bb2df410f7a22decad9a883f7139d5857c1520Chris Lattner//---- ConstantStruct::get() implementation... 1296531daef1542fd6a958c509ccbb6390d33496aae9Chris Lattner// 1297ed468e37a1b15e17e0fd44e0b39bd53bc4174e69Chris Lattner 1298f5ec48d7b5260089e2f3da65508999dcc19f14ceChris Lattner// destroyConstant - Remove the constant from the constant table... 1299f5ec48d7b5260089e2f3da65508999dcc19f14ceChris Lattner// 130004fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantStruct::destroyConstant() { 13011afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner getType()->getContext().pImpl->StructConstants.remove(this); 1302f5ec48d7b5260089e2f3da65508999dcc19f14ceChris Lattner destroyConstantImpl(); 1303f5ec48d7b5260089e2f3da65508999dcc19f14ceChris Lattner} 1304f5ec48d7b5260089e2f3da65508999dcc19f14ceChris Lattner 1305715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke// destroyConstant - Remove the constant from the constant table... 1306715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke// 130704fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantVector::destroyConstant() { 13081afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner getType()->getContext().pImpl->VectorConstants.remove(this); 1309715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke destroyConstantImpl(); 1310715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke} 1311715c90ba524e736190a6380695ab337eeb5148beBrian Gaeke 13122333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands/// getSplatValue - If this is a splat vector constant, meaning that all of 13132333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands/// the elements have the same value, return that value. Otherwise return 0. 13142333e29be441d9d55920651e0b2add23ab0c1613Duncan SandsConstant *Constant::getSplatValue() const { 13152333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert(this->getType()->isVectorTy() && "Only valid for vectors!"); 13162333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands if (isa<ConstantAggregateZero>(this)) 13172333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands return getNullValue(this->getType()->getVectorElementType()); 13182333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands if (const ConstantDataVector *CV = dyn_cast<ConstantDataVector>(this)) 13192333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands return CV->getSplatValue(); 13202333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands if (const ConstantVector *CV = dyn_cast<ConstantVector>(this)) 13212333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands return CV->getSplatValue(); 1322dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 13232333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands} 13242333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands 13253b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman/// getSplatValue - If this is a splat constant, where all of the 13263b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman/// elements have the same value, return that value. Otherwise return null. 13277681c6da606efcc392f76b8acea8301cb5fc7a0aDuncan SandsConstant *ConstantVector::getSplatValue() const { 13283b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman // Check out first element. 13293b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman Constant *Elt = getOperand(0); 13303b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman // Then make sure all remaining elements point to the same value. 13313b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman for (unsigned I = 1, E = getNumOperands(); I < E; ++I) 13323e19473af308325801fbdd27abc56c8afcfde2cbChris Lattner if (getOperand(I) != Elt) 1333dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 13343b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman return Elt; 13353b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman} 13363b7cf0aabafc1c7a89a5a978d4a4307c891027ceDan Gohman 13372333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands/// If C is a constant integer then return its value, otherwise C must be a 13382333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands/// vector of constant integers, all equal, and the common value is returned. 13392333e29be441d9d55920651e0b2add23ab0c1613Duncan Sandsconst APInt &Constant::getUniqueInteger() const { 13402333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands if (const ConstantInt *CI = dyn_cast<ConstantInt>(this)) 13412333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands return CI->getValue(); 13422333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert(this->getSplatValue() && "Doesn't contain a unique integer!"); 13432333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands const Constant *C = this->getAggregateElement(0U); 13442333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert(C && isa<ConstantInt>(C) && "Not a vector of numbers!"); 13452333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands return cast<ConstantInt>(C)->getValue(); 13462333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands} 13472333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands 13482333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands 13492ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner//---- ConstantPointerNull::get() implementation. 13506a57baa295bb3dbd389581df968536f594709bdbChris Lattner// 135102ec5ede6cf10163086a27241508fc5778e39737Chris Lattner 1352db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstantPointerNull *ConstantPointerNull::get(PointerType *Ty) { 13539df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner ConstantPointerNull *&Entry = Ty->getContext().pImpl->CPNConstants[Ty]; 1354dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!Entry) 13559df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner Entry = new ConstantPointerNull(Ty); 1356a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 13579df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner return Entry; 13586a57baa295bb3dbd389581df968536f594709bdbChris Lattner} 13596a57baa295bb3dbd389581df968536f594709bdbChris Lattner 136041661fdb2e963610b399c8ebe51a507847ef997dChris Lattner// destroyConstant - Remove the constant from the constant table... 136141661fdb2e963610b399c8ebe51a507847ef997dChris Lattner// 136204fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantPointerNull::destroyConstant() { 13639df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner getContext().pImpl->CPNConstants.erase(getType()); 13649df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner // Free the constant and any dangling references to it. 136541661fdb2e963610b399c8ebe51a507847ef997dChris Lattner destroyConstantImpl(); 136641661fdb2e963610b399c8ebe51a507847ef997dChris Lattner} 136741661fdb2e963610b399c8ebe51a507847ef997dChris Lattner 136841661fdb2e963610b399c8ebe51a507847ef997dChris Lattner 13692ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner//---- UndefValue::get() implementation. 1370b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner// 1371b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner 1372db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerUndefValue *UndefValue::get(Type *Ty) { 13739df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner UndefValue *&Entry = Ty->getContext().pImpl->UVConstants[Ty]; 1374dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!Entry) 13759df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner Entry = new UndefValue(Ty); 1376a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 13779df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner return Entry; 1378b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner} 1379b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner 1380b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner// destroyConstant - Remove the constant from the constant table. 1381b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner// 138204fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid UndefValue::destroyConstant() { 13839df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner // Free the constant and any dangling references to it. 13849df0fb4e8176325d713ba4eb67791e36cb833432Chris Lattner getContext().pImpl->UVConstants.erase(getType()); 1385b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner destroyConstantImpl(); 1386b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner} 1387b9f18592a62b5f60d20ee6d498df0086b1813b21Chris Lattner 13882ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner//---- BlockAddress::get() implementation. 13892ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner// 13902ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 13912ee11eccdde14c95c78773be76b02bb5fd09d7eeChris LattnerBlockAddress *BlockAddress::get(BasicBlock *BB) { 1392dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(BB->getParent() && "Block must have a parent"); 13932ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner return get(BB->getParent(), BB); 13942ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner} 13952ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 13962ee11eccdde14c95c78773be76b02bb5fd09d7eeChris LattnerBlockAddress *BlockAddress::get(Function *F, BasicBlock *BB) { 13972ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner BlockAddress *&BA = 13982ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner F->getContext().pImpl->BlockAddresses[std::make_pair(F, BB)]; 1399dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!BA) 14002ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner BA = new BlockAddress(F, BB); 1401a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 14022ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner assert(BA->getFunction() == F && "Basic block moved between functions"); 14032ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner return BA; 14042ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner} 14052ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 14062ee11eccdde14c95c78773be76b02bb5fd09d7eeChris LattnerBlockAddress::BlockAddress(Function *F, BasicBlock *BB) 14072ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner: Constant(Type::getInt8PtrTy(F->getContext()), Value::BlockAddressVal, 14082ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner &Op<0>(), 2) { 1409d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner setOperand(0, F); 1410d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner setOperand(1, BB); 1411cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner BB->AdjustBlockAddressRefCount(1); 14122ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner} 14132ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 141436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen HinesBlockAddress *BlockAddress::lookup(const BasicBlock *BB) { 141536b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines if (!BB->hasAddressTaken()) 1416dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 141736b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines 141836b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines const Function *F = BB->getParent(); 1419dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(F && "Block must have a parent"); 142036b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines BlockAddress *BA = 142136b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines F->getContext().pImpl->BlockAddresses.lookup(std::make_pair(F, BB)); 142236b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines assert(BA && "Refcount and block address map disagree!"); 142336b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines return BA; 142436b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines} 14252ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 14262ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner// destroyConstant - Remove the constant from the constant table. 14272ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner// 14282ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattnervoid BlockAddress::destroyConstant() { 14291afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner getFunction()->getType()->getContext().pImpl 14302ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner ->BlockAddresses.erase(std::make_pair(getFunction(), getBasicBlock())); 1431cdfc940912d56a63b6f12eaa7f3faf79cf74c693Chris Lattner getBasicBlock()->AdjustBlockAddressRefCount(-1); 14322ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner destroyConstantImpl(); 14332ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner} 14342ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 14352ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattnervoid BlockAddress::replaceUsesOfWithOnConstant(Value *From, Value *To, Use *U) { 14362ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // This could be replacing either the Basic Block or the Function. In either 14372ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // case, we have to remove the map entry. 14382ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner Function *NewF = getFunction(); 14392ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner BasicBlock *NewBB = getBasicBlock(); 1440a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 14412ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner if (U == &Op<0>()) 1442c06e5cf2e3724762a6c9830a00395736ec07d81aDerek Schuff NewF = cast<Function>(To->stripPointerCasts()); 14432ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner else 14442ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner NewBB = cast<BasicBlock>(To); 1445a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 14462ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // See if the 'new' entry already exists, if not, just update this in place 14472ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // and return early. 14482ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner BlockAddress *&NewBA = 14492ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner getContext().pImpl->BlockAddresses[std::make_pair(NewF, NewBB)]; 1450dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!NewBA) { 1451d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner getBasicBlock()->AdjustBlockAddressRefCount(-1); 1452a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 14532ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // Remove the old entry, this can't cause the map to rehash (just a 14542ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // tombstone will get added). 14552ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner getContext().pImpl->BlockAddresses.erase(std::make_pair(getFunction(), 14562ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner getBasicBlock())); 14572ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner NewBA = this; 1458d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner setOperand(0, NewF); 1459d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner setOperand(1, NewBB); 1460d0ec2352ae14acd4526ac04783e28c3280a26fb8Chris Lattner getBasicBlock()->AdjustBlockAddressRefCount(1); 14612ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner return; 14622ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner } 14632ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 14642ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // Otherwise, I do need to replace this with an existing value. 14652ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner assert(NewBA != this && "I didn't contain From!"); 1466a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 14672ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner // Everyone using this now uses the replacement. 1468678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner replaceAllUsesWith(NewBA); 1469a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 14702ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner destroyConstant(); 14712ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner} 14722ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner 14732ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner//---- ConstantExpr::get() implementations. 1474345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve// 147579e21d338c60b4b5a5746fc45e37ea0310606aeeReid Spencer 14763da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer/// This is a utility function to handle folding of casts and lookup of the 147766a1a05c86721b2769ef107d39675afe3c79b913Duncan Sands/// cast in the ExprConstants map. It is used by the various get* methods below. 14783da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencerstatic inline Constant *getFoldedCast( 1479db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Instruction::CastOps opc, Constant *C, Type *Ty) { 14809eacf8aac8fa19ec5f3e849747af860b023e4dc4Chris Lattner assert(Ty->isFirstClassType() && "Cannot cast to an aggregate type!"); 14813da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer // Fold a few common cases 1482b29d596072d2ba32a0bb59241baf7a1c0ff5ed94Chris Lattner if (Constant *FC = ConstantFoldCastInstruction(opc, C, Ty)) 14833da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer return FC; 1484d628f6a9a47dcb157db01a0568772fed1efcfe90Chris Lattner 1485d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson LLVMContextImpl *pImpl = Ty->getContext().pImpl; 1486d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 148782e905aae4fe815fc57f50663467cb03e4c9e9e1Nadav Rotem // Look up the constant in the table first to ensure uniqueness. 148855d8f6d49023de5182efbb29d0b3bd0035909d62Nadav Rotem ExprMapKeyType Key(opc, C); 1489a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1490d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return pImpl->ExprConstants.getOrCreate(Ty, Key); 1491345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve} 1492a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1493db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getCast(unsigned oc, Constant *C, Type *Ty) { 14943da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer Instruction::CastOps opc = Instruction::CastOps(oc); 14953da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer assert(Instruction::isCast(opc) && "opcode out of range"); 14963da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer assert(C && Ty && "Null arguments to getCast"); 14970b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner assert(CastInst::castIsValid(opc, C, Ty) && "Invalid constantexpr cast!"); 14983da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 14993da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer switch (opc) { 15000b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner default: 15010b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner llvm_unreachable("Invalid cast opcode"); 15020b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::Trunc: return getTrunc(C, Ty); 15030b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::ZExt: return getZExt(C, Ty); 15040b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::SExt: return getSExt(C, Ty); 15050b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::FPTrunc: return getFPTrunc(C, Ty); 15060b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::FPExt: return getFPExtend(C, Ty); 15070b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::UIToFP: return getUIToFP(C, Ty); 15080b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::SIToFP: return getSIToFP(C, Ty); 15090b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::FPToUI: return getFPToUI(C, Ty); 15100b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::FPToSI: return getFPToSI(C, Ty); 15110b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::PtrToInt: return getPtrToInt(C, Ty); 15120b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::IntToPtr: return getIntToPtr(C, Ty); 15130b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner case Instruction::BitCast: return getBitCast(C, Ty); 151459d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault case Instruction::AddrSpaceCast: return getAddrSpaceCast(C, Ty); 1515f5ac6c27acd65ae2c9eafd355b781123d9882087Chris Lattner } 1516a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova} 15177858b336f23405a96ee25de1b9071aeaf270bd77Reid Spencer 1518db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getZExtOrBitCast(Constant *C, Type *Ty) { 15196de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 15203b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getBitCast(C, Ty); 15213b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getZExt(C, Ty); 1522848414e49c7600e3002a4366de52d03a9638b327Reid Spencer} 1523848414e49c7600e3002a4366de52d03a9638b327Reid Spencer 1524db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getSExtOrBitCast(Constant *C, Type *Ty) { 15256de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 15263b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getBitCast(C, Ty); 15273b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getSExt(C, Ty); 1528848414e49c7600e3002a4366de52d03a9638b327Reid Spencer} 1529848414e49c7600e3002a4366de52d03a9638b327Reid Spencer 1530db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getTruncOrBitCast(Constant *C, Type *Ty) { 15316de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman if (C->getType()->getScalarSizeInBits() == Ty->getScalarSizeInBits()) 15323b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getBitCast(C, Ty); 15333b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getTrunc(C, Ty); 1534848414e49c7600e3002a4366de52d03a9638b327Reid Spencer} 1535848414e49c7600e3002a4366de52d03a9638b327Reid Spencer 1536db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getPointerCast(Constant *S, Type *Ty) { 1537655578f8b5275e7c59b87d4709b0d56b2621caacEvgeniy Stepanov assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); 1538655578f8b5275e7c59b87d4709b0d56b2621caacEvgeniy Stepanov assert((Ty->isIntOrIntVectorTy() || Ty->isPtrOrPtrVectorTy()) && 1539655578f8b5275e7c59b87d4709b0d56b2621caacEvgeniy Stepanov "Invalid cast"); 1540c0459fb7f52ca1bcba977f3e72abc050af078aeeReid Spencer 1541655578f8b5275e7c59b87d4709b0d56b2621caacEvgeniy Stepanov if (Ty->isIntOrIntVectorTy()) 15423b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getPtrToInt(S, Ty); 154359d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault 154459d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault unsigned SrcAS = S->getType()->getPointerAddressSpace(); 154559d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault if (Ty->isPtrOrPtrVectorTy() && SrcAS != Ty->getPointerAddressSpace()) 154659d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault return getAddrSpaceCast(S, Ty); 154759d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault 15483b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getBitCast(S, Ty); 1549c0459fb7f52ca1bcba977f3e72abc050af078aeeReid Spencer} 1550c0459fb7f52ca1bcba977f3e72abc050af078aeeReid Spencer 1551cf5f97edf1355be0d7847c73559f8f2b73b54074Bill WendlingConstant *ConstantExpr::getPointerBitCastOrAddrSpaceCast(Constant *S, 1552cf5f97edf1355be0d7847c73559f8f2b73b54074Bill Wendling Type *Ty) { 1553cf5f97edf1355be0d7847c73559f8f2b73b54074Bill Wendling assert(S->getType()->isPtrOrPtrVectorTy() && "Invalid cast"); 1554cf5f97edf1355be0d7847c73559f8f2b73b54074Bill Wendling assert(Ty->isPtrOrPtrVectorTy() && "Invalid cast"); 1555cf5f97edf1355be0d7847c73559f8f2b73b54074Bill Wendling 1556cf5f97edf1355be0d7847c73559f8f2b73b54074Bill Wendling if (S->getType()->getPointerAddressSpace() != Ty->getPointerAddressSpace()) 1557cf5f97edf1355be0d7847c73559f8f2b73b54074Bill Wendling return getAddrSpaceCast(S, Ty); 1558cf5f97edf1355be0d7847c73559f8f2b73b54074Bill Wendling 1559cf5f97edf1355be0d7847c73559f8f2b73b54074Bill Wendling return getBitCast(S, Ty); 1560cf5f97edf1355be0d7847c73559f8f2b73b54074Bill Wendling} 1561cf5f97edf1355be0d7847c73559f8f2b73b54074Bill Wendling 1562cf5f97edf1355be0d7847c73559f8f2b73b54074Bill WendlingConstant *ConstantExpr::getIntegerCast(Constant *C, Type *Ty, 156384f3eab017d56b6854155f2350759dc77ac48aadReid Spencer bool isSigned) { 1564b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && 1565b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands Ty->isIntOrIntVectorTy() && "Invalid cast"); 15666de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman unsigned SrcBits = C->getType()->getScalarSizeInBits(); 15676de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman unsigned DstBits = Ty->getScalarSizeInBits(); 156884f3eab017d56b6854155f2350759dc77ac48aadReid Spencer Instruction::CastOps opcode = 156984f3eab017d56b6854155f2350759dc77ac48aadReid Spencer (SrcBits == DstBits ? Instruction::BitCast : 157084f3eab017d56b6854155f2350759dc77ac48aadReid Spencer (SrcBits > DstBits ? Instruction::Trunc : 157184f3eab017d56b6854155f2350759dc77ac48aadReid Spencer (isSigned ? Instruction::SExt : Instruction::ZExt))); 157284f3eab017d56b6854155f2350759dc77ac48aadReid Spencer return getCast(opcode, C, Ty); 157384f3eab017d56b6854155f2350759dc77ac48aadReid Spencer} 157484f3eab017d56b6854155f2350759dc77ac48aadReid Spencer 1575db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getFPCast(Constant *C, Type *Ty) { 1576b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && 157784f3eab017d56b6854155f2350759dc77ac48aadReid Spencer "Invalid cast"); 15786de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman unsigned SrcBits = C->getType()->getScalarSizeInBits(); 15796de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman unsigned DstBits = Ty->getScalarSizeInBits(); 1580f25212a223b649bf602d3a0489254139cd2c07e4Reid Spencer if (SrcBits == DstBits) 1581f25212a223b649bf602d3a0489254139cd2c07e4Reid Spencer return C; // Avoid a useless cast 158284f3eab017d56b6854155f2350759dc77ac48aadReid Spencer Instruction::CastOps opcode = 15839afc527671618e6cd878c29f5a3ac63598486994Jay Foad (SrcBits > DstBits ? Instruction::FPTrunc : Instruction::FPExt); 158484f3eab017d56b6854155f2350759dc77ac48aadReid Spencer return getCast(opcode, C, Ty); 158584f3eab017d56b6854155f2350759dc77ac48aadReid Spencer} 158684f3eab017d56b6854155f2350759dc77ac48aadReid Spencer 1587db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getTrunc(Constant *C, Type *Ty) { 15886de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#ifndef NDEBUG 15896de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 15906de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool toVec = Ty->getTypeID() == Type::VectorTyID; 15916de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#endif 15926de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1593b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && "Trunc operand must be integer"); 1594b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(Ty->isIntOrIntVectorTy() && "Trunc produces only integral"); 15956de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert(C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&& 15963da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "SrcTy must be larger than DestTy for Trunc!"); 15973da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 159804fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::Trunc, C, Ty); 15993da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16003da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1601db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getSExt(Constant *C, Type *Ty) { 16026de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#ifndef NDEBUG 16036de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 16046de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool toVec = Ty->getTypeID() == Type::VectorTyID; 16056de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#endif 16066de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1607b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && "SExt operand must be integral"); 1608b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(Ty->isIntOrIntVectorTy() && "SExt produces only integer"); 16096de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&& 16103da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "SrcTy must be smaller than DestTy for SExt!"); 16113da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 161204fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::SExt, C, Ty); 1613d144f42a5aa0e9c41b0bf478ea20742c09e9a015Chris Lattner} 1614d144f42a5aa0e9c41b0bf478ea20742c09e9a015Chris Lattner 1615db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getZExt(Constant *C, Type *Ty) { 16166de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#ifndef NDEBUG 16176de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 16186de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool toVec = Ty->getTypeID() == Type::VectorTyID; 16196de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#endif 16206de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1621b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && "ZEXt operand must be integral"); 1622b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(Ty->isIntOrIntVectorTy() && "ZExt produces only integer"); 16236de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert(C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&& 16243da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "SrcTy must be smaller than DestTy for ZExt!"); 16253da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 162604fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::ZExt, C, Ty); 16273da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16283da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1629db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getFPTrunc(Constant *C, Type *Ty) { 16306de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#ifndef NDEBUG 16316de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 16326de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool toVec = Ty->getTypeID() == Type::VectorTyID; 16336de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#endif 16346de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1635b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && 16366de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman C->getType()->getScalarSizeInBits() > Ty->getScalarSizeInBits()&& 16373da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "This is an illegal floating point truncation!"); 163804fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::FPTrunc, C, Ty); 16393da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16403da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1641db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getFPExtend(Constant *C, Type *Ty) { 16426de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#ifndef NDEBUG 16436de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 16446de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman bool toVec = Ty->getTypeID() == Type::VectorTyID; 16456de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman#endif 16466de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1647b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && Ty->isFPOrFPVectorTy() && 16486de29f8d960505421d61c80cdb738e16720b6c0eDan Gohman C->getType()->getScalarSizeInBits() < Ty->getScalarSizeInBits()&& 16493da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "This is an illegal floating point extension!"); 165004fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::FPExt, C, Ty); 16513da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16523da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1653db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getUIToFP(Constant *C, Type *Ty) { 1654b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#ifndef NDEBUG 1655b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 1656b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool toVec = Ty->getTypeID() == Type::VectorTyID; 1657b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#endif 1658b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1659b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() && 1660b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman "This is an illegal uint to floating point cast!"); 166104fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::UIToFP, C, Ty); 16623da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16633da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1664db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getSIToFP(Constant *C, Type *Ty) { 1665b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#ifndef NDEBUG 1666b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 1667b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool toVec = Ty->getTypeID() == Type::VectorTyID; 1668b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#endif 1669b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1670b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && Ty->isFPOrFPVectorTy() && 16713da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer "This is an illegal sint to floating point cast!"); 167204fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::SIToFP, C, Ty); 16733da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16743da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1675db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getFPToUI(Constant *C, Type *Ty) { 1676b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#ifndef NDEBUG 1677b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 1678b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool toVec = Ty->getTypeID() == Type::VectorTyID; 1679b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#endif 1680b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1681b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() && 1682b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman "This is an illegal floating point to uint cast!"); 168304fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::FPToUI, C, Ty); 16843da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16853da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1686db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getFPToSI(Constant *C, Type *Ty) { 1687b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#ifndef NDEBUG 1688b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool fromVec = C->getType()->getTypeID() == Type::VectorTyID; 1689b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman bool toVec = Ty->getTypeID() == Type::VectorTyID; 1690b6dc9352b0d8361609c310699ce58a517fdc2264Devang Patel#endif 1691b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman assert((fromVec == toVec) && "Cannot convert from scalar to/from vector"); 1692b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && Ty->isIntOrIntVectorTy() && 1693b348d18caf834bc26a80e60aa7a2c9b1748734e8Nate Begeman "This is an illegal floating point to sint cast!"); 169404fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::FPToSI, C, Ty); 16953da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 16963da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1697db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getPtrToInt(Constant *C, Type *DstTy) { 16981608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem assert(C->getType()->getScalarType()->isPointerTy() && 16991608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem "PtrToInt source must be pointer or pointer vector"); 17001608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem assert(DstTy->getScalarType()->isIntegerTy() && 17011608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem "PtrToInt destination must be integer or integer vector"); 1702af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy)); 17031486ae626f1af5c2797f4d13e9c57b3a0e473811Nick Lewycky if (isa<VectorType>(C->getType())) 1704230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner assert(C->getType()->getVectorNumElements()==DstTy->getVectorNumElements()&& 1705af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner "Invalid cast between a different number of vector elements"); 170604fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::PtrToInt, C, DstTy); 17073da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 17083da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1709db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getIntToPtr(Constant *C, Type *DstTy) { 17101608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem assert(C->getType()->getScalarType()->isIntegerTy() && 17111608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem "IntToPtr source must be integer or integer vector"); 17121608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem assert(DstTy->getScalarType()->isPointerTy() && 17131608769abeb1430dc34f31ffac0d9850f99ae36aNadav Rotem "IntToPtr destination must be a pointer or pointer vector"); 1714af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner assert(isa<VectorType>(C->getType()) == isa<VectorType>(DstTy)); 17151486ae626f1af5c2797f4d13e9c57b3a0e473811Nick Lewycky if (isa<VectorType>(C->getType())) 1716230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner assert(C->getType()->getVectorNumElements()==DstTy->getVectorNumElements()&& 1717af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner "Invalid cast between a different number of vector elements"); 171804fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::IntToPtr, C, DstTy); 17193da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer} 17203da59db637a887474c1b1346c1f3ccf53b6c4663Reid Spencer 1721db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getBitCast(Constant *C, Type *DstTy) { 17220b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner assert(CastInst::castIsValid(Instruction::BitCast, C, DstTy) && 17230b68a009f63412d4aa7c5f2d68b899e6e1dcc257Chris Lattner "Invalid constantexpr bitcast!"); 1724a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 17258c7f24a36ad7d5aa7322a64d22666fec35fb8478Chris Lattner // It is common to ask for a bitcast of a value to its own type, handle this 17268c7f24a36ad7d5aa7322a64d22666fec35fb8478Chris Lattner // speedily. 17278c7f24a36ad7d5aa7322a64d22666fec35fb8478Chris Lattner if (C->getType() == DstTy) return C; 1728a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 172904fb7c36a9977127f32558dc01c39a9c2388bc39Owen Anderson return getFoldedCast(Instruction::BitCast, C, DstTy); 1730d144f42a5aa0e9c41b0bf478ea20742c09e9a015Chris Lattner} 1731d144f42a5aa0e9c41b0bf478ea20742c09e9a015Chris Lattner 173259d3ae6cdc4316ad338cd848251f33a236ccb36cMatt ArsenaultConstant *ConstantExpr::getAddrSpaceCast(Constant *C, Type *DstTy) { 173359d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault assert(CastInst::castIsValid(Instruction::AddrSpaceCast, C, DstTy) && 173459d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault "Invalid constantexpr addrspacecast!"); 173559d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault 1736cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // Canonicalize addrspacecasts between different pointer types by first 1737cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // bitcasting the pointer type and then converting the address space. 1738cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines PointerType *SrcScalarTy = cast<PointerType>(C->getType()->getScalarType()); 1739cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines PointerType *DstScalarTy = cast<PointerType>(DstTy->getScalarType()); 1740cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines Type *DstElemTy = DstScalarTy->getElementType(); 1741cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (SrcScalarTy->getElementType() != DstElemTy) { 1742cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines Type *MidTy = PointerType::get(DstElemTy, SrcScalarTy->getAddressSpace()); 1743cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines if (VectorType *VT = dyn_cast<VectorType>(DstTy)) { 1744cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines // Handle vectors of pointers. 1745cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines MidTy = VectorType::get(MidTy, VT->getNumElements()); 1746cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 1747cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines C = getBitCast(C, MidTy); 1748cd81d94322a39503e4a3e87b6ee03d4fcb3465fbStephen Hines } 174959d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault return getFoldedCast(Instruction::AddrSpaceCast, C, DstTy); 175059d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault} 175159d3ae6cdc4316ad338cd848251f33a236ccb36cMatt Arsenault 1752eaf79809e8a78bf407bb26b9d7c59f32c142188aChris LattnerConstant *ConstantExpr::get(unsigned Opcode, Constant *C1, Constant *C2, 1753eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner unsigned Flags) { 1754eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner // Check the operands for consistency first. 17550a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer assert(Opcode >= Instruction::BinaryOpsBegin && 17560a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer Opcode < Instruction::BinaryOpsEnd && 1757f31f583b153dacac9f91d6109cdfad140ad0cec1Chris Lattner "Invalid opcode in binary constant expression"); 1758f31f583b153dacac9f91d6109cdfad140ad0cec1Chris Lattner assert(C1->getType() == C2->getType() && 1759f31f583b153dacac9f91d6109cdfad140ad0cec1Chris Lattner "Operand types in binary constant expression should match"); 1760a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 176191b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner#ifndef NDEBUG 176291b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner switch (Opcode) { 1763ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Add: 17640a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::Sub: 1765ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::Mul: 1766ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1767b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isIntOrIntVectorTy() && 1768ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman "Tried to create an integer operation on a non-integer type!"); 1769ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman break; 1770ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FAdd: 1771ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FSub: 1772ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman case Instruction::FMul: 177391b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1774b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isFPOrFPVectorTy() && 1775ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman "Tried to create a floating-point operation on a " 1776ae3a0be92e33bc716722aa600983fc1535acb122Dan Gohman "non-floating-point type!"); 177791b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner break; 17781628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::UDiv: 17791628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::SDiv: 17801628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1781b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isIntOrIntVectorTy() && 17821628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer "Tried to create an arithmetic operation on a non-arithmetic type!"); 17831628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer break; 17841628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer case Instruction::FDiv: 17851628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1786b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isFPOrFPVectorTy() && 1787f57478f381e77e3afd8139fabe7faed991b40d69Dan Gohman "Tried to create an arithmetic operation on a non-arithmetic type!"); 17881628cec4d7fce310d9cde0bcc73997e5a71692c4Reid Spencer break; 17890a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::URem: 17900a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::SRem: 17910a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1792b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isIntOrIntVectorTy() && 17930a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer "Tried to create an arithmetic operation on a non-arithmetic type!"); 17940a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer break; 17950a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer case Instruction::FRem: 17960a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1797b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isFPOrFPVectorTy() && 1798f57478f381e77e3afd8139fabe7faed991b40d69Dan Gohman "Tried to create an arithmetic operation on a non-arithmetic type!"); 17990a783f783ca05c961234385f5b269d4cf03dbbdbReid Spencer break; 180091b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner case Instruction::And: 180191b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner case Instruction::Or: 180291b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner case Instruction::Xor: 180391b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1804b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isIntOrIntVectorTy() && 18051bae291cb9cafc8a8c86538449b78a575ed9834aMisha Brukman "Tried to create a logical operation on a non-integral type!"); 180691b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner break; 180791b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner case Instruction::Shl: 18083822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer case Instruction::LShr: 18093822ff5c71478c7c90a50ca57045fb676fcb5005Reid Spencer case Instruction::AShr: 1810832254e1c2387c0cbeb0a820b8315fbe85cb003aReid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1811b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C1->getType()->isIntOrIntVectorTy() && 181291b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner "Tried to create a shift operation on a non-integer type!"); 181391b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner break; 181491b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner default: 181591b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner break; 181691b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner } 181791b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner#endif 181891b362bba9dbc9945262f0f74f00e1cf3a67c814Chris Lattner 1819eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner if (Constant *FC = ConstantFoldBinaryInstruction(Opcode, C1, C2)) 1820eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return FC; // Fold a few common cases. 1821a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 18224e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { C1, C2 }; 18234e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer ExprMapKeyType Key(Opcode, ArgVec, 0, Flags); 1824a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1825eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = C1->getContext().pImpl; 1826eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return pImpl->ExprConstants.getOrCreate(C1->getType(), Key); 182767263fec757aa7b8a3c7efe1290dc5415aa59c35Reid Spencer} 182867263fec757aa7b8a3c7efe1290dc5415aa59c35Reid Spencer 1829db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getSizeOf(Type* Ty) { 1830baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson // sizeof is implemented as: (i64) gep (Ty*)null, 1 1831baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson // Note that a non-inbounds gep is used, as null isn't within any object. 18321d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Constant *GEPIdx = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1); 1833baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *GEP = getGetElementPtr( 1834dab3d29605a5c83db41b28176273ef55961120c1Jay Foad Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx); 18353b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getPtrToInt(GEP, 18363b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman Type::getInt64Ty(Ty->getContext())); 1837baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 1838baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 1839db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getAlignOf(Type* Ty) { 18400f5efe56258f8cd6ceff4d7955a5d80144cd9cb0Dan Gohman // alignof is implemented as: (i64) gep ({i1,Ty}*)null, 0, 1 1841e2574d3215c412a15763d26aee9aa5d856764c2cDan Gohman // Note that a non-inbounds gep is used, as null isn't within any object. 1842db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *AligningTy = 1843b2318662b6d2e6d9ea9917fd280dde0ba9a938adChris Lattner StructType::get(Type::getInt1Ty(Ty->getContext()), Ty, NULL); 1844dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Constant *NullPtr = Constant::getNullValue(AligningTy->getPointerTo(0)); 184506ed3e788ab3d71350b7cc7d077f4bd9a2b57799Dan Gohman Constant *Zero = ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0); 18461d0be15f89cb5056e20e2d24faa8d6afb1573bcaOwen Anderson Constant *One = ConstantInt::get(Type::getInt32Ty(Ty->getContext()), 1); 1847baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson Constant *Indices[2] = { Zero, One }; 1848dab3d29605a5c83db41b28176273ef55961120c1Jay Foad Constant *GEP = getGetElementPtr(NullPtr, Indices); 18493b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getPtrToInt(GEP, 18503b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman Type::getInt64Ty(Ty->getContext())); 1851baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 1852baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 1853db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getOffsetOf(StructType* STy, unsigned FieldNo) { 18542544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman return getOffsetOf(STy, ConstantInt::get(Type::getInt32Ty(STy->getContext()), 18552544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman FieldNo)); 18562544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman} 18572544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman 1858db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris LattnerConstant *ConstantExpr::getOffsetOf(Type* Ty, Constant *FieldNo) { 18593778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman // offsetof is implemented as: (i64) gep (Ty*)null, 0, FieldNo 18603778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman // Note that a non-inbounds gep is used, as null isn't within any object. 18613778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman Constant *GEPIdx[] = { 18622544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman ConstantInt::get(Type::getInt64Ty(Ty->getContext()), 0), 18632544a1de666ad7197c755b4dab6419f42df01f65Dan Gohman FieldNo 18643778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman }; 18653778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman Constant *GEP = getGetElementPtr( 1866dab3d29605a5c83db41b28176273ef55961120c1Jay Foad Constant::getNullValue(PointerType::getUnqual(Ty)), GEPIdx); 18673b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman return getPtrToInt(GEP, 18683b49063a83eecaa9dc05c29d27768f85c0622163Dan Gohman Type::getInt64Ty(Ty->getContext())); 18693778f21b17e675c2fd1600901361fa4a73888ebaDan Gohman} 1870baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 1871eaf79809e8a78bf407bb26b9d7c59f32c142188aChris LattnerConstant *ConstantExpr::getCompare(unsigned short Predicate, 1872eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner Constant *C1, Constant *C2) { 187367263fec757aa7b8a3c7efe1290dc5415aa59c35Reid Spencer assert(C1->getType() == C2->getType() && "Op types should be identical!"); 1874a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1875eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner switch (Predicate) { 1876eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner default: llvm_unreachable("Invalid CmpInst predicate"); 1877eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_FALSE: case CmpInst::FCMP_OEQ: case CmpInst::FCMP_OGT: 1878eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_OGE: case CmpInst::FCMP_OLT: case CmpInst::FCMP_OLE: 1879eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_ONE: case CmpInst::FCMP_ORD: case CmpInst::FCMP_UNO: 1880eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_UEQ: case CmpInst::FCMP_UGT: case CmpInst::FCMP_UGE: 1881eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_ULT: case CmpInst::FCMP_ULE: case CmpInst::FCMP_UNE: 1882eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::FCMP_TRUE: 1883eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return getFCmp(Predicate, C1, C2); 1884a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1885eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::ICMP_EQ: case CmpInst::ICMP_NE: case CmpInst::ICMP_UGT: 1886eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::ICMP_UGE: case CmpInst::ICMP_ULT: case CmpInst::ICMP_ULE: 1887eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::ICMP_SGT: case CmpInst::ICMP_SGE: case CmpInst::ICMP_SLT: 1888eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner case CmpInst::ICMP_SLE: 1889eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return getICmp(Predicate, C1, C2); 1890eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner } 1891c3d12f082397ec069cad1466967cef37c2fef185Chris Lattner} 1892c3d12f082397ec069cad1466967cef37c2fef185Chris Lattner 1893eaf79809e8a78bf407bb26b9d7c59f32c142188aChris LattnerConstant *ConstantExpr::getSelect(Constant *C, Constant *V1, Constant *V2) { 18949ace0cdb12be5e9c213567209ace721dfeccaddfChris Lattner assert(!SelectInst::areInvalidOperands(C, V1, V2)&&"Invalid select operands"); 189508a45cc2ffc7698ee1f74b71afd9d4fb8e49daf8Chris Lattner 1896eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner if (Constant *SC = ConstantFoldSelectInstruction(C, V1, V2)) 1897eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return SC; // Fold common cases 189808a45cc2ffc7698ee1f74b71afd9d4fb8e49daf8Chris Lattner 18994e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { C, V1, V2 }; 19004e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer ExprMapKeyType Key(Instruction::Select, ArgVec); 1901a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1902eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = C->getContext().pImpl; 1903eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return pImpl->ExprConstants.getOrCreate(V1->getType(), Key); 190408a45cc2ffc7698ee1f74b71afd9d4fb8e49daf8Chris Lattner} 190508a45cc2ffc7698ee1f74b71afd9d4fb8e49daf8Chris Lattner 1906dab3d29605a5c83db41b28176273ef55961120c1Jay FoadConstant *ConstantExpr::getGetElementPtr(Constant *C, ArrayRef<Value *> Idxs, 1907dab3d29605a5c83db41b28176273ef55961120c1Jay Foad bool InBounds) { 19082333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert(C->getType()->isPtrOrPtrVectorTy() && 19092333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands "Non-pointer type for constant GetElementPtr expression"); 19102333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands 1911dab3d29605a5c83db41b28176273ef55961120c1Jay Foad if (Constant *FC = ConstantFoldGetElementPtr(C, InBounds, Idxs)) 19121f78d51be69964b38c5fc76ceb2147b737d09857Chris Lattner return FC; // Fold a few common cases. 1913f8dbee7cea072eb63ae343759975109553697bcbDan Gohman 1914eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner // Get the result type of the getelementptr! 1915a9203109f4ac95aa7e9624f2838e3d89623ec902Jay Foad Type *Ty = GetElementPtrInst::getIndexedType(C->getType(), Idxs); 1916eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner assert(Ty && "GEP indices invalid!"); 1917230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner unsigned AS = C->getType()->getPointerAddressSpace(); 1918eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner Type *ReqTy = Ty->getPointerTo(AS); 19192333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands if (VectorType *VecTy = dyn_cast<VectorType>(C->getType())) 19202333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands ReqTy = VectorType::get(ReqTy, VecTy->getNumElements()); 1921a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1922f8dbee7cea072eb63ae343759975109553697bcbDan Gohman // Look up the constant in the table first to ensure uniqueness 1923f8dbee7cea072eb63ae343759975109553697bcbDan Gohman std::vector<Constant*> ArgVec; 1924dab3d29605a5c83db41b28176273ef55961120c1Jay Foad ArgVec.reserve(1 + Idxs.size()); 1925f8dbee7cea072eb63ae343759975109553697bcbDan Gohman ArgVec.push_back(C); 19262333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands for (unsigned i = 0, e = Idxs.size(); i != e; ++i) { 19272333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert(Idxs[i]->getType()->isVectorTy() == ReqTy->isVectorTy() && 19282333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands "getelementptr index type missmatch"); 19292333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands assert((!Idxs[i]->getType()->isVectorTy() || 19302333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands ReqTy->getVectorNumElements() == 19312333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands Idxs[i]->getType()->getVectorNumElements()) && 19322333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands "getelementptr index type missmatch"); 1933f8dbee7cea072eb63ae343759975109553697bcbDan Gohman ArgVec.push_back(cast<Constant>(Idxs[i])); 19342333e29be441d9d55920651e0b2add23ab0c1613Duncan Sands } 1935f8dbee7cea072eb63ae343759975109553697bcbDan Gohman const ExprMapKeyType Key(Instruction::GetElementPtr, ArgVec, 0, 19361f78d51be69964b38c5fc76ceb2147b737d09857Chris Lattner InBounds ? GEPOperator::IsInBounds : 0); 1937a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1938eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = C->getContext().pImpl; 1939f8dbee7cea072eb63ae343759975109553697bcbDan Gohman return pImpl->ExprConstants.getOrCreate(ReqTy, Key); 1940f8dbee7cea072eb63ae343759975109553697bcbDan Gohman} 1941f8dbee7cea072eb63ae343759975109553697bcbDan Gohman 1942077d0eb1bd54b71143139a5184d291454d638ebcReid SpencerConstant * 1943401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick LewyckyConstantExpr::getICmp(unsigned short pred, Constant *LHS, Constant *RHS) { 1944077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer assert(LHS->getType() == RHS->getType()); 1945077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer assert(pred >= ICmpInst::FIRST_ICMP_PREDICATE && 1946077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer pred <= ICmpInst::LAST_ICMP_PREDICATE && "Invalid ICmp Predicate"); 1947077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1948b29d596072d2ba32a0bb59241baf7a1c0ff5ed94Chris Lattner if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS)) 1949077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer return FC; // Fold a few common cases... 1950077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1951077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer // Look up the constant in the table first to ensure uniqueness 19524e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { LHS, RHS }; 19534fa021a1a9e062683e203d775bae897fb8b75facReid Spencer // Get the key type with both the opcode and predicate 1954077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer const ExprMapKeyType Key(Instruction::ICmp, ArgVec, pred); 195531c36f02f26def914727a521e7ca5fad450920caOwen Anderson 1956db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ResultTy = Type::getInt1Ty(LHS->getContext()); 1957db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VT = dyn_cast<VectorType>(LHS->getType())) 1958401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky ResultTy = VectorType::get(ResultTy, VT->getNumElements()); 1959401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky 1960d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl; 1961401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky return pImpl->ExprConstants.getOrCreate(ResultTy, Key); 1962077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer} 1963077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1964077d0eb1bd54b71143139a5184d291454d638ebcReid SpencerConstant * 1965401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick LewyckyConstantExpr::getFCmp(unsigned short pred, Constant *LHS, Constant *RHS) { 1966077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer assert(LHS->getType() == RHS->getType()); 1967077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer assert(pred <= FCmpInst::LAST_FCMP_PREDICATE && "Invalid FCmp Predicate"); 1968077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1969b29d596072d2ba32a0bb59241baf7a1c0ff5ed94Chris Lattner if (Constant *FC = ConstantFoldCompareInstruction(pred, LHS, RHS)) 1970077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer return FC; // Fold a few common cases... 1971077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1972077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer // Look up the constant in the table first to ensure uniqueness 19734e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { LHS, RHS }; 19744fa021a1a9e062683e203d775bae897fb8b75facReid Spencer // Get the key type with both the opcode and predicate 1975077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer const ExprMapKeyType Key(Instruction::FCmp, ArgVec, pred); 1976401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky 1977db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ResultTy = Type::getInt1Ty(LHS->getContext()); 1978db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner if (VectorType *VT = dyn_cast<VectorType>(LHS->getType())) 1979401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky ResultTy = VectorType::get(ResultTy, VT->getNumElements()); 1980401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky 1981d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson LLVMContextImpl *pImpl = LHS->getType()->getContext().pImpl; 1982401f3258f6e72cbc3e1f5e17c3976b241feb1c66Nick Lewycky return pImpl->ExprConstants.getOrCreate(ResultTy, Key); 1983077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer} 1984077d0eb1bd54b71143139a5184d291454d638ebcReid Spencer 1985b52ee7f5ffd189c4f21ab227c6a24061ef3378fcRobert BocchinoConstant *ConstantExpr::getExtractElement(Constant *Val, Constant *Idx) { 19861df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(Val->getType()->isVectorTy() && 1987ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer "Tried to create extractelement operation on non-vector type!"); 1988dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(Idx->getType()->isIntegerTy() && 1989dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines "Extractelement index must be an integer type!"); 1990a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1991eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner if (Constant *FC = ConstantFoldExtractElementInstruction(Val, Idx)) 199283738a20ddb64838f94461320c6af8ae2a8329baChris Lattner return FC; // Fold a few common cases. 1993a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1994c152f9cd26e7cb32352c513389a18ffd892ecaecRobert Bocchino // Look up the constant in the table first to ensure uniqueness 19954e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { Val, Idx }; 19964e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer const ExprMapKeyType Key(Instruction::ExtractElement, ArgVec); 1997a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 1998eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = Val->getContext().pImpl; 1999230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner Type *ReqTy = Val->getType()->getVectorElementType(); 2000d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return pImpl->ExprConstants.getOrCreate(ReqTy, Key); 2001c152f9cd26e7cb32352c513389a18ffd892ecaecRobert Bocchino} 2002c152f9cd26e7cb32352c513389a18ffd892ecaecRobert Bocchino 2003c152f9cd26e7cb32352c513389a18ffd892ecaecRobert BocchinoConstant *ConstantExpr::getInsertElement(Constant *Val, Constant *Elt, 2004c152f9cd26e7cb32352c513389a18ffd892ecaecRobert Bocchino Constant *Idx) { 20051df9859c40492511b8aa4321eb76496005d3b75bDuncan Sands assert(Val->getType()->isVectorTy() && 2006ac9dcb94dde5f166ee29372385c0e3b695227ab4Reid Spencer "Tried to create insertelement operation on non-vector type!"); 2007230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner assert(Elt->getType() == Val->getType()->getVectorElementType() && 2008230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner "Insertelement types must match!"); 2009dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines assert(Idx->getType()->isIntegerTy() && 20103d10b0b2d35be0c99fe95c6d0c4931916c8a59cfReid Spencer "Insertelement index must be i32 type!"); 2011c152f9cd26e7cb32352c513389a18ffd892ecaecRobert Bocchino 2012eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner if (Constant *FC = ConstantFoldInsertElementInstruction(Val, Elt, Idx)) 2013eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return FC; // Fold a few common cases. 201400f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner // Look up the constant in the table first to ensure uniqueness 20154e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { Val, Elt, Idx }; 20164e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer const ExprMapKeyType Key(Instruction::InsertElement, ArgVec); 2017a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2018eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = Val->getContext().pImpl; 2019eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return pImpl->ExprConstants.getOrCreate(Val->getType(), Key); 202000f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner} 202100f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner 202200f1023cf8b30c74dc219525f518a80c45b6e7baChris LattnerConstant *ConstantExpr::getShuffleVector(Constant *V1, Constant *V2, 202300f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner Constant *Mask) { 202400f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner assert(ShuffleVectorInst::isValidOperands(V1, V2, Mask) && 202500f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner "Invalid shuffle vector constant expr operands!"); 20260f123cf732ad249117b7471e37bf819633b76a6eNate Begeman 2027eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner if (Constant *FC = ConstantFoldShuffleVectorInstruction(V1, V2, Mask)) 2028eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return FC; // Fold a few common cases. 2029eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner 2030230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner unsigned NElts = Mask->getType()->getVectorNumElements(); 2031230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner Type *EltTy = V1->getType()->getVectorElementType(); 2032db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ShufTy = VectorType::get(EltTy, NElts); 203300f1023cf8b30c74dc219525f518a80c45b6e7baChris Lattner 2034eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner // Look up the constant in the table first to ensure uniqueness 20354e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer Constant *ArgVec[] = { V1, V2, Mask }; 20364e4cc7dae8d2b2f8a07c38f4d61e0b94b13d008bBenjamin Kramer const ExprMapKeyType Key(Instruction::ShuffleVector, ArgVec); 2037a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2038eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner LLVMContextImpl *pImpl = ShufTy->getContext().pImpl; 2039eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner return pImpl->ExprConstants.getOrCreate(ShufTy, Key); 2040041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman} 2041041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman 2042041e2eb51721bcfecee5d9c9fc409ff185526e47Dan GohmanConstant *ConstantExpr::getInsertValue(Constant *Agg, Constant *Val, 2043fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad ArrayRef<unsigned> Idxs) { 204410050d19e857396e65289c05ce9714e0a570deedHal Finkel assert(Agg->getType()->isFirstClassType() && 204510050d19e857396e65289c05ce9714e0a570deedHal Finkel "Non-first-class type for constant insertvalue expression"); 204610050d19e857396e65289c05ce9714e0a570deedHal Finkel 2047fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad assert(ExtractValueInst::getIndexedType(Agg->getType(), 2048fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad Idxs) == Val->getType() && 2049eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner "insertvalue indices invalid!"); 205010050d19e857396e65289c05ce9714e0a570deedHal Finkel Type *ReqTy = Val->getType(); 205110050d19e857396e65289c05ce9714e0a570deedHal Finkel 205210050d19e857396e65289c05ce9714e0a570deedHal Finkel if (Constant *FC = ConstantFoldInsertValueInstruction(Agg, Val, Idxs)) 205310050d19e857396e65289c05ce9714e0a570deedHal Finkel return FC; 205410050d19e857396e65289c05ce9714e0a570deedHal Finkel 205510050d19e857396e65289c05ce9714e0a570deedHal Finkel Constant *ArgVec[] = { Agg, Val }; 205610050d19e857396e65289c05ce9714e0a570deedHal Finkel const ExprMapKeyType Key(Instruction::InsertValue, ArgVec, 0, 0, Idxs); 205710050d19e857396e65289c05ce9714e0a570deedHal Finkel 205810050d19e857396e65289c05ce9714e0a570deedHal Finkel LLVMContextImpl *pImpl = Agg->getContext().pImpl; 205910050d19e857396e65289c05ce9714e0a570deedHal Finkel return pImpl->ExprConstants.getOrCreate(ReqTy, Key); 2060041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman} 2061041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman 2062041e2eb51721bcfecee5d9c9fc409ff185526e47Dan GohmanConstant *ConstantExpr::getExtractValue(Constant *Agg, 2063fc6d3a49867cd38954dc40936a88f1907252c6d2Jay Foad ArrayRef<unsigned> Idxs) { 2064e4569943d936d73dec6f36f545e9902095bd3fd8Dan Gohman assert(Agg->getType()->isFirstClassType() && 2065e4569943d936d73dec6f36f545e9902095bd3fd8Dan Gohman "Tried to create extractelement operation on non-first-class type!"); 2066041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman 2067db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *ReqTy = ExtractValueInst::getIndexedType(Agg->getType(), Idxs); 2068dc770fcb2c84068a64b471fe6c4c56966cf3021fChandler Carruth (void)ReqTy; 2069041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman assert(ReqTy && "extractvalue indices invalid!"); 2070a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2071eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner assert(Agg->getType()->isFirstClassType() && 2072eaf79809e8a78bf407bb26b9d7c59f32c142188aChris Lattner "Non-first-class type for constant extractvalue expression"); 207310050d19e857396e65289c05ce9714e0a570deedHal Finkel if (Constant *FC = ConstantFoldExtractValueInstruction(Agg, Idxs)) 207410050d19e857396e65289c05ce9714e0a570deedHal Finkel return FC; 207510050d19e857396e65289c05ce9714e0a570deedHal Finkel 207610050d19e857396e65289c05ce9714e0a570deedHal Finkel Constant *ArgVec[] = { Agg }; 207710050d19e857396e65289c05ce9714e0a570deedHal Finkel const ExprMapKeyType Key(Instruction::ExtractValue, ArgVec, 0, 0, Idxs); 207810050d19e857396e65289c05ce9714e0a570deedHal Finkel 207910050d19e857396e65289c05ce9714e0a570deedHal Finkel LLVMContextImpl *pImpl = Agg->getContext().pImpl; 208010050d19e857396e65289c05ce9714e0a570deedHal Finkel return pImpl->ExprConstants.getOrCreate(ReqTy, Key); 2081041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman} 2082041e2eb51721bcfecee5d9c9fc409ff185526e47Dan Gohman 208381baf14fdfa29c22a08d609144c285169e23a247Chris LattnerConstant *ConstantExpr::getNeg(Constant *C, bool HasNUW, bool HasNSW) { 2084b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && 2085baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson "Cannot NEG a nonintegral value!"); 208681baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return getSub(ConstantFP::getZeroValueForNegation(C->getType()), 208781baf14fdfa29c22a08d609144c285169e23a247Chris Lattner C, HasNUW, HasNSW); 2088baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2089baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2090f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFNeg(Constant *C) { 2091b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isFPOrFPVectorTy() && 2092baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson "Cannot FNEG a non-floating-point value!"); 209381baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return getFSub(ConstantFP::getZeroValueForNegation(C->getType()), C); 2094baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2095baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2096f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getNot(Constant *C) { 2097b0bc6c361da9009e8414efde317d9bbff755f6c0Duncan Sands assert(C->getType()->isIntOrIntVectorTy() && 2098baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson "Cannot NOT a nonintegral value!"); 2099a7235ea7245028a0723e8ab7fd011386b3900777Owen Anderson return get(Instruction::Xor, C, Constant::getAllOnesValue(C->getType())); 2100baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2101baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 210281baf14fdfa29c22a08d609144c285169e23a247Chris LattnerConstant *ConstantExpr::getAdd(Constant *C1, Constant *C2, 210381baf14fdfa29c22a08d609144c285169e23a247Chris Lattner bool HasNUW, bool HasNSW) { 210481baf14fdfa29c22a08d609144c285169e23a247Chris Lattner unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | 210581baf14fdfa29c22a08d609144c285169e23a247Chris Lattner (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); 210681baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return get(Instruction::Add, C1, C2, Flags); 2107baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2108baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2109f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFAdd(Constant *C1, Constant *C2) { 2110baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::FAdd, C1, C2); 2111baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2112baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 211381baf14fdfa29c22a08d609144c285169e23a247Chris LattnerConstant *ConstantExpr::getSub(Constant *C1, Constant *C2, 211481baf14fdfa29c22a08d609144c285169e23a247Chris Lattner bool HasNUW, bool HasNSW) { 211581baf14fdfa29c22a08d609144c285169e23a247Chris Lattner unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | 211681baf14fdfa29c22a08d609144c285169e23a247Chris Lattner (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); 211781baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return get(Instruction::Sub, C1, C2, Flags); 2118baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2119baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2120f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFSub(Constant *C1, Constant *C2) { 2121baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::FSub, C1, C2); 2122baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2123baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 212481baf14fdfa29c22a08d609144c285169e23a247Chris LattnerConstant *ConstantExpr::getMul(Constant *C1, Constant *C2, 212581baf14fdfa29c22a08d609144c285169e23a247Chris Lattner bool HasNUW, bool HasNSW) { 212681baf14fdfa29c22a08d609144c285169e23a247Chris Lattner unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | 212781baf14fdfa29c22a08d609144c285169e23a247Chris Lattner (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); 212881baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return get(Instruction::Mul, C1, C2, Flags); 2129baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2130baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2131f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFMul(Constant *C1, Constant *C2) { 2132baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::FMul, C1, C2); 2133baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2134baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 213574f5c5abeafeaabefab470390ce0e7a36754c592Chris LattnerConstant *ConstantExpr::getUDiv(Constant *C1, Constant *C2, bool isExact) { 213674f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner return get(Instruction::UDiv, C1, C2, 213774f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner isExact ? PossiblyExactOperator::IsExact : 0); 2138baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2139baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 214074f5c5abeafeaabefab470390ce0e7a36754c592Chris LattnerConstant *ConstantExpr::getSDiv(Constant *C1, Constant *C2, bool isExact) { 214174f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner return get(Instruction::SDiv, C1, C2, 214274f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner isExact ? PossiblyExactOperator::IsExact : 0); 2143baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2144baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2145f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFDiv(Constant *C1, Constant *C2) { 2146baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::FDiv, C1, C2); 2147baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2148baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2149f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getURem(Constant *C1, Constant *C2) { 2150baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::URem, C1, C2); 2151baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2152baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2153f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getSRem(Constant *C1, Constant *C2) { 2154baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::SRem, C1, C2); 2155baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2156baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2157f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getFRem(Constant *C1, Constant *C2) { 2158baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::FRem, C1, C2); 2159baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2160baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2161f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getAnd(Constant *C1, Constant *C2) { 2162baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::And, C1, C2); 2163baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2164baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2165f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getOr(Constant *C1, Constant *C2) { 2166baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::Or, C1, C2); 2167baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2168baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2169f067d584a81ae771d301304ea885e55e2de8ee9aChris LattnerConstant *ConstantExpr::getXor(Constant *C1, Constant *C2) { 2170baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson return get(Instruction::Xor, C1, C2); 2171baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2172baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 217381baf14fdfa29c22a08d609144c285169e23a247Chris LattnerConstant *ConstantExpr::getShl(Constant *C1, Constant *C2, 217481baf14fdfa29c22a08d609144c285169e23a247Chris Lattner bool HasNUW, bool HasNSW) { 217581baf14fdfa29c22a08d609144c285169e23a247Chris Lattner unsigned Flags = (HasNUW ? OverflowingBinaryOperator::NoUnsignedWrap : 0) | 217681baf14fdfa29c22a08d609144c285169e23a247Chris Lattner (HasNSW ? OverflowingBinaryOperator::NoSignedWrap : 0); 217781baf14fdfa29c22a08d609144c285169e23a247Chris Lattner return get(Instruction::Shl, C1, C2, Flags); 2178baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2179baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 218074f5c5abeafeaabefab470390ce0e7a36754c592Chris LattnerConstant *ConstantExpr::getLShr(Constant *C1, Constant *C2, bool isExact) { 218174f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner return get(Instruction::LShr, C1, C2, 218274f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner isExact ? PossiblyExactOperator::IsExact : 0); 2183baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2184baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 218574f5c5abeafeaabefab470390ce0e7a36754c592Chris LattnerConstant *ConstantExpr::getAShr(Constant *C1, Constant *C2, bool isExact) { 218674f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner return get(Instruction::AShr, C1, C2, 218774f5c5abeafeaabefab470390ce0e7a36754c592Chris Lattner isExact ? PossiblyExactOperator::IsExact : 0); 2188baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson} 2189baf3c404409d5e47b13984a7f95bfbd6d1f2e79eOwen Anderson 2190c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// getBinOpIdentity - Return the identity for the given binary operation, 2191c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands/// i.e. a constant C such that X op C = X and C op X = X for every X. It 2192ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands/// returns null if the operator doesn't have an identity. 2193c038a7833565ecf92a699371d448135a097c9e2fDuncan SandsConstant *ConstantExpr::getBinOpIdentity(unsigned Opcode, Type *Ty) { 2194c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands switch (Opcode) { 2195c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands default: 2196ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands // Doesn't have an identity. 2197dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2198ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands 2199c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands case Instruction::Add: 2200c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands case Instruction::Or: 2201c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands case Instruction::Xor: 2202c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands return Constant::getNullValue(Ty); 2203c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands 2204c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands case Instruction::Mul: 2205c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands return ConstantInt::get(Ty, 1); 2206c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands 2207c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands case Instruction::And: 2208c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands return Constant::getAllOnesValue(Ty); 2209c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands } 2210c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands} 2211c038a7833565ecf92a699371d448135a097c9e2fDuncan Sands 2212ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands/// getBinOpAbsorber - Return the absorbing element for the given binary 2213ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands/// operation, i.e. a constant C such that X op C = C and C op X = C for 2214ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands/// every X. For example, this returns zero for integer multiplication. 2215ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands/// It returns null if the operator doesn't have an absorbing element. 2216ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan SandsConstant *ConstantExpr::getBinOpAbsorber(unsigned Opcode, Type *Ty) { 2217ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands switch (Opcode) { 2218ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands default: 2219ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands // Doesn't have an absorber. 2220dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2221ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands 2222ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands case Instruction::Or: 2223ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands return Constant::getAllOnesValue(Ty); 2224ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands 2225ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands case Instruction::And: 2226ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands case Instruction::Mul: 2227ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands return Constant::getNullValue(Ty); 2228ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands } 2229ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands} 2230ee5a094ccf1f04d3fcc92ac4d2fc8a2926cbb232Duncan Sands 2231d0b1bb01f2847f53320fb1088100293e70405067Vikram S. Adve// destroyConstant - Remove the constant from the constant table... 2232d0b1bb01f2847f53320fb1088100293e70405067Vikram S. Adve// 223304fb7c36a9977127f32558dc01c39a9c2388bc39Owen Andersonvoid ConstantExpr::destroyConstant() { 22341afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner getType()->getContext().pImpl->ExprConstants.remove(this); 2235d0b1bb01f2847f53320fb1088100293e70405067Vikram S. Adve destroyConstantImpl(); 2236345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve} 2237345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve 2238c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattnerconst char *ConstantExpr::getOpcodeName() const { 2239c188eeb08c873da142a47398be6c405ce3f34f51Chris Lattner return Instruction::getOpcodeName(getOpcode()); 2240345e0cfb86b182c744e618ad39b5181f46110365Vikram S. Adve} 22411c9c8e64d22bcab91ce2321a06b2b5640a6ae927Reid Spencer 224204e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner 224304e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner 224404e3b1ef788cfac266896c6e89050c4ff60114e2Chris LattnerGetElementPtrConstantExpr:: 2245a7c698823e4ffa4589bde1ff6de60b6af0cdba5aChris LattnerGetElementPtrConstantExpr(Constant *C, ArrayRef<Constant*> IdxList, 2246db125cfaf57cc83e7dd7453de2d509bc8efd0e5eChris Lattner Type *DestTy) 224704e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner : ConstantExpr(DestTy, Instruction::GetElementPtr, 224804e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner OperandTraits<GetElementPtrConstantExpr>::op_end(this) 224904e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner - (IdxList.size()+1), IdxList.size()+1) { 225004e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner OperandList[0] = C; 225104e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner for (unsigned i = 0, E = IdxList.size(); i != E; ++i) 225204e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner OperandList[i+1] = IdxList[i]; 225304e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner} 225404e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner 225527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner//===----------------------------------------------------------------------===// 225627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner// ConstantData* implementations 225727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 225827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattnervoid ConstantDataArray::anchor() {} 225927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattnervoid ConstantDataVector::anchor() {} 226027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 226145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementType - Return the element type of the array/vector. 226245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris LattnerType *ConstantDataSequential::getElementType() const { 226345bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return getType()->getElementType(); 226445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 226545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 22669e631da253bff90d9da5ace21bd73f1c838e72ebChris LattnerStringRef ConstantDataSequential::getRawDataValues() const { 22671ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner return StringRef(DataElements, getNumElements()*getElementByteSize()); 22689e631da253bff90d9da5ace21bd73f1c838e72ebChris Lattner} 22699e631da253bff90d9da5ace21bd73f1c838e72ebChris Lattner 2270ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// isElementTypeCompatible - Return true if a ConstantDataSequential can be 2271ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// formed with a vector or array of the specified element type. 2272ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// ConstantDataArray only works with normal float and int types that are 2273ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner/// stored densely in memory, not with things like i42 or x86_f80. 2274ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattnerbool ConstantDataSequential::isElementTypeCompatible(const Type *Ty) { 227545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner if (Ty->isFloatTy() || Ty->isDoubleTy()) return true; 227645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner if (const IntegerType *IT = dyn_cast<IntegerType>(Ty)) { 227745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner switch (IT->getBitWidth()) { 227845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner case 8: 227945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner case 16: 228045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner case 32: 228145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner case 64: 228245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return true; 228345bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner default: break; 228445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner } 228545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner } 228645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return false; 228745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 228845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 22891ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner/// getNumElements - Return the number of elements in the array or vector. 22901ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattnerunsigned ConstantDataSequential::getNumElements() const { 2291af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner if (ArrayType *AT = dyn_cast<ArrayType>(getType())) 2292af7b4fb9bec3858f0374d713dcbf3398a23c6fbeChris Lattner return AT->getNumElements(); 2293230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner return getType()->getVectorNumElements(); 22941ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner} 22951ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 22961ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner 229745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementByteSize - Return the size in bytes of the elements in the data. 229845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattneruint64_t ConstantDataSequential::getElementByteSize() const { 229945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return getElementType()->getPrimitiveSizeInBits()/8; 230045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 230145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 230245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementPointer - Return the start of the specified element. 230345bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattnerconst char *ConstantDataSequential::getElementPointer(unsigned Elt) const { 23041ee0ecf84a07693c3a517ba030fac8ac1f9f3fbcChris Lattner assert(Elt < getNumElements() && "Invalid Elt"); 230545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return DataElements+Elt*getElementByteSize(); 230645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 230745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 230845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 230927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// isAllZeros - return true if the array is empty or all zeros. 231027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattnerstatic bool isAllZeros(StringRef Arr) { 231127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner for (StringRef::iterator I = Arr.begin(), E = Arr.end(); I != E; ++I) 231227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner if (*I != 0) 231327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return false; 231427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return true; 231527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 2316ff2b7f3cd66793e36a36500acb36b9d1a0489d4cChris Lattner 231727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// getImpl - This is the underlying implementation of all of the 231827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// ConstantDataSequential::get methods. They all thunk down to here, providing 23198cf27efe4000c194efec4004afa83d12031c6d55Chris Lattner/// the correct element type. We take the bytes in as a StringRef because 232027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// we *want* an underlying "char*" to avoid TBAA type punning violations. 232127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris LattnerConstant *ConstantDataSequential::getImpl(StringRef Elements, Type *Ty) { 2322230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner assert(isElementTypeCompatible(Ty->getSequentialElementType())); 232329cc6cb4d1aa22f0a27edf4e5b363071a83a65d8Chris Lattner // If the elements are all zero or there are no elements, return a CAZ, which 232429cc6cb4d1aa22f0a27edf4e5b363071a83a65d8Chris Lattner // is more dense and canonical. 232527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner if (isAllZeros(Elements)) 232627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return ConstantAggregateZero::get(Ty); 232727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 232827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Do a lookup to see if we have already formed one of these. 232927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner StringMap<ConstantDataSequential*>::MapEntryTy &Slot = 233027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Ty->getContext().pImpl->CDSConstants.GetOrCreateValue(Elements); 2331a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 233227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // The bucket can point to a linked list of different CDS's that have the same 233327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // body but different types. For example, 0,0,0,1 could be a 4 element array 233427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // of i8, or a 1-element array of i32. They'll both end up in the same 233527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner /// StringMap bucket, linked up by their Next pointers. Walk the list. 233627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner ConstantDataSequential **Entry = &Slot.getValue(); 2337dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines for (ConstantDataSequential *Node = *Entry; Node; 233827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Entry = &Node->Next, Node = *Entry) 233927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner if (Node->getType() == Ty) 234027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return Node; 2341a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 234227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Okay, we didn't get a hit. Create a node of the right class, link it in, 234327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // and return it. 234427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner if (isa<ArrayType>(Ty)) 234527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return *Entry = new ConstantDataArray(Ty, Slot.getKeyData()); 234627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 234727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner assert(isa<VectorType>(Ty)); 234827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner return *Entry = new ConstantDataVector(Ty, Slot.getKeyData()); 234927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 235027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 235127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattnervoid ConstantDataSequential::destroyConstant() { 235227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Remove the constant from the StringMap. 235327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner StringMap<ConstantDataSequential*> &CDSConstants = 235427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner getType()->getContext().pImpl->CDSConstants; 2355a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 235627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner StringMap<ConstantDataSequential*>::iterator Slot = 23579e631da253bff90d9da5ace21bd73f1c838e72ebChris Lattner CDSConstants.find(getRawDataValues()); 235827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 235927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner assert(Slot != CDSConstants.end() && "CDS not found in uniquing table"); 236027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 236127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner ConstantDataSequential **Entry = &Slot->getValue(); 236227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 236327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Remove the entry from the hash table. 2364dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines if (!(*Entry)->Next) { 236527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // If there is only one value in the bucket (common case) it must be this 236627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // entry, and removing the entry should remove the bucket completely. 236727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner assert((*Entry) == this && "Hash mismatch in ConstantDataSequential"); 236827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner getContext().pImpl->CDSConstants.erase(Slot); 236927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner } else { 237027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Otherwise, there are multiple entries linked off the bucket, unlink the 237127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // node we care about but keep the bucket around. 237227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner for (ConstantDataSequential *Node = *Entry; ; 237327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Entry = &Node->Next, Node = *Entry) { 237427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner assert(Node && "Didn't find entry in its uniquing hash table!"); 237527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // If we found our entry, unlink it from the list and we're done. 237627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner if (Node == this) { 237727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner *Entry = Node->Next; 237827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner break; 237927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner } 238027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner } 238127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner } 2382a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 238327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // If we were part of a list, make sure that we don't delete the list that is 238427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // still owned by the uniquing map. 2385dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Next = nullptr; 2386a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 238727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner // Finally, actually delete it. 238827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner destroyConstantImpl(); 238927dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 239027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 239127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// get() constructors - Return a constant with array type with an element 239227dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// count and element type matching the ArrayRef passed in. Note that this 239327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// can return a ConstantAggregateZero object. 239432100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint8_t> Elts) { 239527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getInt8Ty(Context), Elts.size()); 2396a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2397a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*1), Ty); 239827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 239932100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint16_t> Elts){ 240027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getInt16Ty(Context), Elts.size()); 2401a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2402a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*2), Ty); 240327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 240432100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint32_t> Elts){ 240527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getInt32Ty(Context), Elts.size()); 2406a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2407a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); 240827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 240932100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<uint64_t> Elts){ 241027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getInt64Ty(Context), Elts.size()); 2411a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2412a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); 241327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 241432100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<float> Elts) { 241527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getFloatTy(Context), Elts.size()); 2416a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2417a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); 241827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 241932100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::get(LLVMContext &Context, ArrayRef<double> Elts) { 242027dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = ArrayType::get(Type::getDoubleTy(Context), Elts.size()); 2421a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2422a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); 242327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 242427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 242532100602432657b188db603ca3ab50b487938027Chris Lattner/// getString - This method constructs a CDS and initializes it with a text 242632100602432657b188db603ca3ab50b487938027Chris Lattner/// string. The default behavior (AddNull==true) causes a null terminator to 242732100602432657b188db603ca3ab50b487938027Chris Lattner/// be placed at the end of the array (increasing the length of the string by 242832100602432657b188db603ca3ab50b487938027Chris Lattner/// one more than the StringRef would normally indicate. Pass AddNull=false 242932100602432657b188db603ca3ab50b487938027Chris Lattner/// to disable this behavior. 243032100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataArray::getString(LLVMContext &Context, 243132100602432657b188db603ca3ab50b487938027Chris Lattner StringRef Str, bool AddNull) { 2432a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova if (!AddNull) { 2433a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const uint8_t *Data = reinterpret_cast<const uint8_t *>(Str.data()); 2434a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return get(Context, ArrayRef<uint8_t>(const_cast<uint8_t *>(Data), 2435a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova Str.size())); 2436a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova } 2437a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 243832100602432657b188db603ca3ab50b487938027Chris Lattner SmallVector<uint8_t, 64> ElementVals; 243932100602432657b188db603ca3ab50b487938027Chris Lattner ElementVals.append(Str.begin(), Str.end()); 244032100602432657b188db603ca3ab50b487938027Chris Lattner ElementVals.push_back(0); 244132100602432657b188db603ca3ab50b487938027Chris Lattner return get(Context, ElementVals); 244232100602432657b188db603ca3ab50b487938027Chris Lattner} 244327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 244427dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// get() constructors - Return a constant with vector type with an element 244527dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// count and element type matching the ArrayRef passed in. Note that this 244627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner/// can return a ConstantAggregateZero object. 244732100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint8_t> Elts){ 244827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getInt8Ty(Context), Elts.size()); 2449a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2450a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*1), Ty); 245127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 245232100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint16_t> Elts){ 245327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getInt16Ty(Context), Elts.size()); 2454a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2455a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*2), Ty); 245627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 245732100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint32_t> Elts){ 245827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getInt32Ty(Context), Elts.size()); 2459a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2460a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); 246127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 246232100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<uint64_t> Elts){ 246327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getInt64Ty(Context), Elts.size()); 2464a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2465a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); 246627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 246732100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<float> Elts) { 246827dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getFloatTy(Context), Elts.size()); 2469a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2470a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*4), Ty); 247127dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 247232100602432657b188db603ca3ab50b487938027Chris LattnerConstant *ConstantDataVector::get(LLVMContext &Context, ArrayRef<double> Elts) { 247327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner Type *Ty = VectorType::get(Type::getDoubleTy(Context), Elts.size()); 2474a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const char *Data = reinterpret_cast<const char *>(Elts.data()); 2475a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return getImpl(StringRef(const_cast<char *>(Data), Elts.size()*8), Ty); 247627dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner} 247727dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 24783c2c954e0baf4c5029f87277d75cc6ca38916f71Chris LattnerConstant *ConstantDataVector::getSplat(unsigned NumElts, Constant *V) { 24793c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner assert(isElementTypeCompatible(V->getType()) && 24803c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner "Element type not compatible with ConstantData"); 24813c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner if (ConstantInt *CI = dyn_cast<ConstantInt>(V)) { 24823c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner if (CI->getType()->isIntegerTy(8)) { 24833c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner SmallVector<uint8_t, 16> Elts(NumElts, CI->getZExtValue()); 24843c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return get(V->getContext(), Elts); 24853c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner } 24863c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner if (CI->getType()->isIntegerTy(16)) { 24873c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner SmallVector<uint16_t, 16> Elts(NumElts, CI->getZExtValue()); 24883c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return get(V->getContext(), Elts); 24893c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner } 24903c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner if (CI->getType()->isIntegerTy(32)) { 24913c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner SmallVector<uint32_t, 16> Elts(NumElts, CI->getZExtValue()); 24923c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return get(V->getContext(), Elts); 24933c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner } 24943c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner assert(CI->getType()->isIntegerTy(64) && "Unsupported ConstantData type"); 24953c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner SmallVector<uint64_t, 16> Elts(NumElts, CI->getZExtValue()); 24963c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner return get(V->getContext(), Elts); 24973c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner } 24983c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner 249936c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (ConstantFP *CFP = dyn_cast<ConstantFP>(V)) { 250036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (CFP->getType()->isFloatTy()) { 250136c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<float, 16> Elts(NumElts, CFP->getValueAPF().convertToFloat()); 250236c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return get(V->getContext(), Elts); 250336c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 250436c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner if (CFP->getType()->isDoubleTy()) { 250536c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner SmallVector<double, 16> Elts(NumElts, 250636c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner CFP->getValueAPF().convertToDouble()); 250736c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return get(V->getContext(), Elts); 250836c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner } 25093c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner } 251036c744ff10a0963d551cd6c4f439a4147bab8207Chris Lattner return ConstantVector::getSplat(NumElts, V); 25113c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner} 25123c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner 25133c2c954e0baf4c5029f87277d75cc6ca38916f71Chris Lattner 251445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementAsInteger - If this is a sequential container of integers (of 251545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// any size), return the specified element in the low bits of a uint64_t. 251645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattneruint64_t ConstantDataSequential::getElementAsInteger(unsigned Elt) const { 251745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner assert(isa<IntegerType>(getElementType()) && 251845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner "Accessor can only be used when element is an integer"); 251945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner const char *EltPtr = getElementPointer(Elt); 2520a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 252145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner // The data is stored in host byte order, make sure to cast back to the right 252245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner // type to load with the right endianness. 2523230cdab2205d051cc11c565b69ca8c2106904a76Chris Lattner switch (getElementType()->getIntegerBitWidth()) { 252450bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper default: llvm_unreachable("Invalid bitwidth for CDS"); 2525a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case 8: 2526a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(EltPtr)); 2527a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case 16: 2528a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<uint16_t *>(reinterpret_cast<const uint16_t *>(EltPtr)); 2529a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case 32: 2530a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<uint32_t *>(reinterpret_cast<const uint32_t *>(EltPtr)); 2531a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case 64: 2532a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<uint64_t *>(reinterpret_cast<const uint64_t *>(EltPtr)); 253345bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner } 253445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 253545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 253645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementAsAPFloat - If this is a sequential container of floating point 253745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// type, return the specified element as an APFloat. 253845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris LattnerAPFloat ConstantDataSequential::getElementAsAPFloat(unsigned Elt) const { 253945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner const char *EltPtr = getElementPointer(Elt); 254045bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 254145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner switch (getElementType()->getTypeID()) { 25421486ae626f1af5c2797f4d13e9c57b3a0e473811Nick Lewycky default: 254350bee42b54cd9aec5f49566307df2b0cf23afcf6Craig Topper llvm_unreachable("Accessor can only be used when element is float/double!"); 2544a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case Type::FloatTyID: { 2545a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const float *FloatPrt = reinterpret_cast<const float *>(EltPtr); 2546a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return APFloat(*const_cast<float *>(FloatPrt)); 2547a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova } 2548a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova case Type::DoubleTyID: { 2549a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const double *DoublePtr = reinterpret_cast<const double *>(EltPtr); 2550a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return APFloat(*const_cast<double *>(DoublePtr)); 2551a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova } 255245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner } 255345bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 255445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 255545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementAsFloat - If this is an sequential container of floats, return 255645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// the specified element as a float. 255745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattnerfloat ConstantDataSequential::getElementAsFloat(unsigned Elt) const { 255845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner assert(getElementType()->isFloatTy() && 255945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner "Accessor can only be used when element is a 'float'"); 2560a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const float *EltPtr = reinterpret_cast<const float *>(getElementPointer(Elt)); 2561a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<float *>(EltPtr); 256245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 256345bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 256445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementAsDouble - If this is an sequential container of doubles, return 256545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// the specified element as a float. 256645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattnerdouble ConstantDataSequential::getElementAsDouble(unsigned Elt) const { 256745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner assert(getElementType()->isDoubleTy() && 256845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner "Accessor can only be used when element is a 'float'"); 2569a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova const double *EltPtr = 2570a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova reinterpret_cast<const double *>(getElementPointer(Elt)); 2571a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova return *const_cast<double *>(EltPtr); 257245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 257345bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 257445bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// getElementAsConstant - Return a Constant for a specified index's element. 257545bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// Note that this has to compute a new constant to return, so it isn't as 257645bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner/// efficient as getElementAsInteger/Float/Double. 257745bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris LattnerConstant *ConstantDataSequential::getElementAsConstant(unsigned Elt) const { 257845bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner if (getElementType()->isFloatTy() || getElementType()->isDoubleTy()) 257945bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return ConstantFP::get(getContext(), getElementAsAPFloat(Elt)); 2580a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 258145bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner return ConstantInt::get(getElementType(), getElementAsInteger(Elt)); 258245bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner} 258345bb5c5333fba7e9909cca178d785bf2c1d2b0c1Chris Lattner 258462339073127df4579905f551f61c132cf21d2aadChris Lattner/// isString - This method returns true if this is an array of i8. 258562339073127df4579905f551f61c132cf21d2aadChris Lattnerbool ConstantDataSequential::isString() const { 258662339073127df4579905f551f61c132cf21d2aadChris Lattner return isa<ArrayType>(getType()) && getElementType()->isIntegerTy(8); 258762339073127df4579905f551f61c132cf21d2aadChris Lattner} 258862339073127df4579905f551f61c132cf21d2aadChris Lattner 258962339073127df4579905f551f61c132cf21d2aadChris Lattner/// isCString - This method returns true if the array "isString", ends with a 259062339073127df4579905f551f61c132cf21d2aadChris Lattner/// nul byte, and does not contains any other nul bytes. 259162339073127df4579905f551f61c132cf21d2aadChris Lattnerbool ConstantDataSequential::isCString() const { 259262339073127df4579905f551f61c132cf21d2aadChris Lattner if (!isString()) 259362339073127df4579905f551f61c132cf21d2aadChris Lattner return false; 2594a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 259562339073127df4579905f551f61c132cf21d2aadChris Lattner StringRef Str = getAsString(); 2596a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 259762339073127df4579905f551f61c132cf21d2aadChris Lattner // The last value must be nul. 259862339073127df4579905f551f61c132cf21d2aadChris Lattner if (Str.back() != 0) return false; 2599a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 260062339073127df4579905f551f61c132cf21d2aadChris Lattner // Other elements must be non-nul. 260162339073127df4579905f551f61c132cf21d2aadChris Lattner return Str.drop_back().find(0) == StringRef::npos; 260262339073127df4579905f551f61c132cf21d2aadChris Lattner} 260327dd9cf5d1ec831a1cd0766580e6d1177a9800a3Chris Lattner 2604e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner/// getSplatValue - If this is a splat constant, meaning that all of the 2605e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner/// elements have the same value, return that value. Otherwise return NULL. 2606e150e2df424b162710b36a1ec5ef90270ffb435bChris LattnerConstant *ConstantDataVector::getSplatValue() const { 2607e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner const char *Base = getRawDataValues().data(); 2608a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2609e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner // Compare elements 1+ to the 0'th element. 2610e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner unsigned EltSize = getElementByteSize(); 2611e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner for (unsigned i = 1, e = getNumElements(); i != e; ++i) 2612e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (memcmp(Base, Base+i*EltSize, EltSize)) 2613dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines return nullptr; 2614a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2615e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner // If they're all the same, return the 0th one as a representative. 2616e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner return getElementAsConstant(0); 2617e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner} 261804e3b1ef788cfac266896c6e89050c4ff60114e2Chris Lattner 26195cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner//===----------------------------------------------------------------------===// 26205cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner// replaceUsesOfWithOnConstant implementations 26215cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner 26225498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// replaceUsesOfWithOnConstant - Update this constant array to change uses of 26235498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// 'From' to be uses of 'To'. This must update the uniquing data structures 26245498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// etc. 26255498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// 26265498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// Note that we intentionally replace all uses of From with To here. Consider 26275498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// a large array that uses 'From' 1000 times. By handling this case all here, 26285498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// ConstantArray::replaceUsesOfWithOnConstant is only invoked once, and that 26295498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// single invocation handles all 1000 uses. Handling them one at a time would 26305498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// work, but would be really slow because it would have to unique each updated 26315498405e2d4d21b6893be6e79e0bc43bffe21a58Chris Lattner/// array instance. 26322ee11eccdde14c95c78773be76b02bb5fd09d7eeChris Lattner/// 26335cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattnervoid ConstantArray::replaceUsesOfWithOnConstant(Value *From, Value *To, 2634d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner Use *U) { 26351fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!"); 26361fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson Constant *ToC = cast<Constant>(To); 26371fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson 26381afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner LLVMContextImpl *pImpl = getType()->getContext().pImpl; 26391fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson 26402cb395eae71dacda49ca3fe758618fc3e0701659Talin SmallVector<Constant*, 8> Values; 26412cb395eae71dacda49ca3fe758618fc3e0701659Talin LLVMContextImpl::ArrayConstantsTy::LookupKey Lookup; 26422cb395eae71dacda49ca3fe758618fc3e0701659Talin Lookup.first = cast<ArrayType>(getType()); 26431fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson Values.reserve(getNumOperands()); // Build replacement array. 26441fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson 2645a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova // Fill values with the modified operands of the constant array. Also, 26461fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // compute whether this turns into an all-zeros array. 26471fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson unsigned NumUpdated = 0; 2648a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2649e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner // Keep track of whether all the values in the array are "ToC". 2650e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner bool AllSame = true; 2651e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) { 2652e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Constant *Val = cast<Constant>(O->get()); 2653e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (Val == From) { 2654e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Val = ToC; 2655e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner ++NumUpdated; 26561fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } 2657e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Values.push_back(Val); 26582cb395eae71dacda49ca3fe758618fc3e0701659Talin AllSame &= Val == ToC; 26591fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } 2660a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2661dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Constant *Replacement = nullptr; 2662e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (AllSame && ToC->isNullValue()) { 26631afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Replacement = ConstantAggregateZero::get(getType()); 2664e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } else if (AllSame && isa<UndefValue>(ToC)) { 2665e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Replacement = UndefValue::get(getType()); 26661fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } else { 26671fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // Check to see if we have this array type already. 26682cb395eae71dacda49ca3fe758618fc3e0701659Talin Lookup.second = makeArrayRef(Values); 26691fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson LLVMContextImpl::ArrayConstantsTy::MapTy::iterator I = 26702cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->ArrayConstants.find(Lookup); 2671a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 26722cb395eae71dacda49ca3fe758618fc3e0701659Talin if (I != pImpl->ArrayConstants.map_end()) { 26732cb395eae71dacda49ca3fe758618fc3e0701659Talin Replacement = I->first; 26741fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } else { 26751fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // Okay, the new shape doesn't exist in the system yet. Instead of 26761fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // creating a new constant array, inserting it, replaceallusesof'ing the 26771fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // old with the new, then deleting the old... just update the current one 26781fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // in place! 26792cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->ArrayConstants.remove(this); 2680a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 26811fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // Update to the new value. Optimize for the case when we have a single 26821fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson // operand that we're changing, but handle bulk updates efficiently. 26831fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson if (NumUpdated == 1) { 26841fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson unsigned OperandToUpdate = U - OperandList; 26851fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson assert(getOperand(OperandToUpdate) == From && 26861fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson "ReplaceAllUsesWith broken!"); 26871fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson setOperand(OperandToUpdate, ToC); 26881fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } else { 26891fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson for (unsigned i = 0, e = getNumOperands(); i != e; ++i) 26901fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson if (getOperand(i) == From) 26911fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson setOperand(i, ToC); 26921fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } 26932cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->ArrayConstants.insert(this); 26941fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson return; 26951fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } 26961fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson } 2697a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2698cea141f1d1f85997c4c657009994bdacbc3a3dbfChris Lattner // Otherwise, I do need to replace this with an existing value. 26995cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner assert(Replacement != this && "I didn't contain From!"); 2700a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2701d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner // Everyone using this now uses the replacement. 2702678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner replaceAllUsesWith(Replacement); 2703a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 27045cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner // Delete the old constant! 27055cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner destroyConstant(); 27065cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner} 27075cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner 27085cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattnervoid ConstantStruct::replaceUsesOfWithOnConstant(Value *From, Value *To, 2709d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner Use *U) { 27108fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!"); 27118fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Constant *ToC = cast<Constant>(To); 27128fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson 27138fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson unsigned OperandToUpdate = U-OperandList; 27148fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson assert(getOperand(OperandToUpdate) == From && "ReplaceAllUsesWith broken!"); 27158fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson 27162cb395eae71dacda49ca3fe758618fc3e0701659Talin SmallVector<Constant*, 8> Values; 27172cb395eae71dacda49ca3fe758618fc3e0701659Talin LLVMContextImpl::StructConstantsTy::LookupKey Lookup; 27182cb395eae71dacda49ca3fe758618fc3e0701659Talin Lookup.first = cast<StructType>(getType()); 27198fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Values.reserve(getNumOperands()); // Build replacement struct. 2720a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2721a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova // Fill values with the modified operands of the constant struct. Also, 27228fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // compute whether this turns into an all-zeros struct. 27238fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson bool isAllZeros = false; 2724e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner bool isAllUndef = false; 2725e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (ToC->isNullValue()) { 27268fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson isAllZeros = true; 27278fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) { 27288fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Constant *Val = cast<Constant>(O->get()); 27298fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Values.push_back(Val); 27308fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson if (isAllZeros) isAllZeros = Val->isNullValue(); 27318fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } 2732e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } else if (isa<UndefValue>(ToC)) { 2733e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner isAllUndef = true; 2734e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner for (Use *O = OperandList, *E = OperandList+getNumOperands(); O != E; ++O) { 2735e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Constant *Val = cast<Constant>(O->get()); 2736e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Values.push_back(Val); 2737e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner if (isAllUndef) isAllUndef = isa<UndefValue>(Val); 2738e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } 2739e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } else { 2740e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner for (Use *O = OperandList, *E = OperandList + getNumOperands(); O != E; ++O) 2741e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Values.push_back(cast<Constant>(O->get())); 27428fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } 27438fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Values[OperandToUpdate] = ToC; 2744a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 27451afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner LLVMContextImpl *pImpl = getContext().pImpl; 2746a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2747dce4a407a24b04eebc6a376f8e62b41aaa7b071fStephen Hines Constant *Replacement = nullptr; 27488fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson if (isAllZeros) { 27491afcace3a3a138b1b18e5c6270caa8dae2261ae2Chris Lattner Replacement = ConstantAggregateZero::get(getType()); 2750e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner } else if (isAllUndef) { 2751e150e2df424b162710b36a1ec5ef90270ffb435bChris Lattner Replacement = UndefValue::get(getType()); 27528fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } else { 275393604b6de20f6a2ce160bfa65ef5d99cc8e577f3Chris Lattner // Check to see if we have this struct type already. 27542cb395eae71dacda49ca3fe758618fc3e0701659Talin Lookup.second = makeArrayRef(Values); 27558fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson LLVMContextImpl::StructConstantsTy::MapTy::iterator I = 27562cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->StructConstants.find(Lookup); 2757a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 27582cb395eae71dacda49ca3fe758618fc3e0701659Talin if (I != pImpl->StructConstants.map_end()) { 27592cb395eae71dacda49ca3fe758618fc3e0701659Talin Replacement = I->first; 27608fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } else { 27618fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // Okay, the new shape doesn't exist in the system yet. Instead of 27628fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // creating a new constant struct, inserting it, replaceallusesof'ing the 27638fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // old with the new, then deleting the old... just update the current one 27648fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // in place! 27652cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->StructConstants.remove(this); 2766a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 27678fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson // Update to the new value. 27688fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson setOperand(OperandToUpdate, ToC); 27692cb395eae71dacda49ca3fe758618fc3e0701659Talin pImpl->StructConstants.insert(this); 27708fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson return; 27718fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } 27728fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson } 2773a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 27748fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson assert(Replacement != this && "I didn't contain From!"); 2775a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2776d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner // Everyone using this now uses the replacement. 2777678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner replaceAllUsesWith(Replacement); 2778a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 27795cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner // Delete the old constant! 27805cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner destroyConstant(); 27815cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner} 27825cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner 27839d6565a5b1fbc4286d6ee638d8f47a3171a9ed7eReid Spencervoid ConstantVector::replaceUsesOfWithOnConstant(Value *From, Value *To, 2784d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner Use *U) { 27855cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner assert(isa<Constant>(To) && "Cannot make Constant refer to non-constant!"); 2786a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2787a7c698823e4ffa4589bde1ff6de60b6af0cdba5aChris Lattner SmallVector<Constant*, 8> Values; 27885cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner Values.reserve(getNumOperands()); // Build replacement array... 27895cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 27905cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner Constant *Val = getOperand(i); 27915cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner if (Val == From) Val = cast<Constant>(To); 27925cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner Values.push_back(Val); 27935cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner } 2794a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2795a0c138429e101f573d43740322245c1d5b8b04a0Jay Foad Constant *Replacement = get(Values); 27965cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner assert(Replacement != this && "I didn't contain From!"); 2797a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2798d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner // Everyone using this now uses the replacement. 2799678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner replaceAllUsesWith(Replacement); 2800a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 28015cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner // Delete the old constant! 28025cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner destroyConstant(); 28035cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner} 28045cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner 28055cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattnervoid ConstantExpr::replaceUsesOfWithOnConstant(Value *From, Value *ToV, 2806d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner Use *U) { 28075cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner assert(isa<Constant>(ToV) && "Cannot make Constant refer to non-constant!"); 28085cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner Constant *To = cast<Constant>(ToV); 2809a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 28101a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner SmallVector<Constant*, 8> NewOps; 28111a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner for (unsigned i = 0, e = getNumOperands(); i != e; ++i) { 28121a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner Constant *Op = getOperand(i); 28131a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner NewOps.push_back(Op == From ? To : Op); 28145cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner } 2815a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 28161a8def6ad6b7b114abd31524d73ad8062a82fbc8Chris Lattner Constant *Replacement = getWithOperands(NewOps); 28175cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner assert(Replacement != this && "I didn't contain From!"); 2818a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 2819d0ff1adbdb4b7b565b7f8f191aac0731e80aa1efChris Lattner // Everyone using this now uses the replacement. 2820678f9e05c949bc565b736b0bb4337bffb0f3c687Chris Lattner replaceAllUsesWith(Replacement); 2821a46517e13fd470f71765c260478028afa7df98d2Galina Kistanova 28225cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner // Delete the old constant! 28235cbade9f8340f5266d9f9ba401d494e636b7c42fChris Lattner destroyConstant(); 282410b9de62ff14069a4410f6005eaf71d353b2ac83Matthijs Kooijman} 2825b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2826b9478c2aef060aa6b0ede41c05859c34b1527bf8James MolloyInstruction *ConstantExpr::getAsInstruction() { 2827b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy SmallVector<Value*,4> ValueOperands; 2828b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy for (op_iterator I = op_begin(), E = op_end(); I != E; ++I) 2829b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy ValueOperands.push_back(cast<Value>(I)); 2830b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2831b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy ArrayRef<Value*> Ops(ValueOperands); 2832b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2833b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy switch (getOpcode()) { 2834b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::Trunc: 2835b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::ZExt: 2836b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::SExt: 2837b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::FPTrunc: 2838b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::FPExt: 2839b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::UIToFP: 2840b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::SIToFP: 2841b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::FPToUI: 2842b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::FPToSI: 2843b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::PtrToInt: 2844b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::IntToPtr: 2845b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::BitCast: 284636b56886974eae4f9c5ebc96befd3e7bfe5de338Stephen Hines case Instruction::AddrSpaceCast: 2847b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return CastInst::Create((Instruction::CastOps)getOpcode(), 2848b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy Ops[0], getType()); 2849b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::Select: 2850b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return SelectInst::Create(Ops[0], Ops[1], Ops[2]); 2851b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::InsertElement: 2852b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return InsertElementInst::Create(Ops[0], Ops[1], Ops[2]); 2853b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::ExtractElement: 2854b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return ExtractElementInst::Create(Ops[0], Ops[1]); 2855b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::InsertValue: 2856b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return InsertValueInst::Create(Ops[0], Ops[1], getIndices()); 2857b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::ExtractValue: 2858b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return ExtractValueInst::Create(Ops[0], getIndices()); 2859b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::ShuffleVector: 2860b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return new ShuffleVectorInst(Ops[0], Ops[1], Ops[2]); 2861b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2862b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::GetElementPtr: 2863b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy if (cast<GEPOperator>(this)->isInBounds()) 2864b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return GetElementPtrInst::CreateInBounds(Ops[0], Ops.slice(1)); 2865b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy else 2866b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return GetElementPtrInst::Create(Ops[0], Ops.slice(1)); 2867b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2868b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::ICmp: 2869b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy case Instruction::FCmp: 2870b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return CmpInst::Create((Instruction::OtherOps)getOpcode(), 2871b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy getPredicate(), Ops[0], Ops[1]); 2872b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy 2873b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy default: 2874b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy assert(getNumOperands() == 2 && "Must be binary operator?"); 2875b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy BinaryOperator *BO = 2876b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy BinaryOperator::Create((Instruction::BinaryOps)getOpcode(), 2877b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy Ops[0], Ops[1]); 2878b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy if (isa<OverflowingBinaryOperator>(BO)) { 2879b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy BO->setHasNoUnsignedWrap(SubclassOptionalData & 2880b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy OverflowingBinaryOperator::NoUnsignedWrap); 2881b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy BO->setHasNoSignedWrap(SubclassOptionalData & 2882b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy OverflowingBinaryOperator::NoSignedWrap); 2883b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy } 2884b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy if (isa<PossiblyExactOperator>(BO)) 2885b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy BO->setIsExact(SubclassOptionalData & PossiblyExactOperator::IsExact); 2886b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy return BO; 2887b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy } 2888b9478c2aef060aa6b0ede41c05859c34b1527bf8James Molloy} 2889