LLVMContextImpl.h revision d03eecd063a18ce0c505a87afcb04db26c035bc9
1001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson//===----------------- LLVMContextImpl.h - Implementation ------*- C++ -*--===// 22bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// 32bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// The LLVM Compiler Infrastructure 42bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// 52bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// This file is distributed under the University of Illinois Open Source 62bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// License. See LICENSE.TXT for details. 72bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson// 82bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson//===----------------------------------------------------------------------===// 95217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson// 105217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson// This file declares LLVMContextImpl, the opaque implementation 115217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson// of LLVMContext. 125217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson// 135217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson//===----------------------------------------------------------------------===// 142bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson 152bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson#ifndef LLVM_LLVMCONTEXT_IMPL_H 162bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson#define LLVM_LLVMCONTEXT_IMPL_H 172bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson 18f53c371983908f02678b0e12c5d18466dcc70ffdOwen Anderson#include "llvm/LLVMContext.h" 19eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson#include "llvm/Constants.h" 20f53c371983908f02678b0e12c5d18466dcc70ffdOwen Anderson#include "llvm/DerivedTypes.h" 21d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson#include "llvm/Instructions.h" 22d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson#include "llvm/Operator.h" 2316e298f98024bcff5c7219a96cac216114c30dadOwen Anderson#include "llvm/Support/Debug.h" 2416e298f98024bcff5c7219a96cac216114c30dadOwen Anderson#include "llvm/Support/ErrorHandling.h" 2516e298f98024bcff5c7219a96cac216114c30dadOwen Anderson#include "llvm/System/Mutex.h" 26001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson#include "llvm/System/RWMutex.h" 27914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson#include "llvm/ADT/APFloat.h" 28001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson#include "llvm/ADT/APInt.h" 29001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson#include "llvm/ADT/DenseMap.h" 30ce032b483ca96093b84f69178cdb2d047e124332Owen Anderson#include "llvm/ADT/FoldingSet.h" 31aad3fb7362aff151e97ad457005ea3f2872fe868Owen Anderson#include "llvm/ADT/StringMap.h" 3216e298f98024bcff5c7219a96cac216114c30dadOwen Anderson#include <map> 33006c77df8cc7f6a9dac575600b797b8ba32b29ebOwen Anderson#include <vector> 3416e298f98024bcff5c7219a96cac216114c30dadOwen Anderson 352bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Andersonnamespace llvm { 3616e298f98024bcff5c7219a96cac216114c30dadOwen Andersontemplate<class ValType> 3716e298f98024bcff5c7219a96cac216114c30dadOwen Andersonstruct ConstantTraits; 382bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson 39d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 40d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// UnaryConstantExpr - This class is private to Constants.cpp, and is used 41d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// behind the scenes to implement unary constant exprs. 42d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonclass UnaryConstantExpr : public ConstantExpr { 43d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t, unsigned); // DO NOT IMPLEMENT 44d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonpublic: 45d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // allocate space for exactly one operand 46d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t s) { 47d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return User::operator new(s, 1); 48d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 49d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson UnaryConstantExpr(unsigned Opcode, Constant *C, const Type *Ty) 50d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson : ConstantExpr(Ty, Opcode, &Op<0>(), 1) { 51d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<0>() = C; 52d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 53d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 54d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 55d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 56d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// BinaryConstantExpr - This class is private to Constants.cpp, and is used 57d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// behind the scenes to implement binary constant exprs. 58d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonclass BinaryConstantExpr : public ConstantExpr { 59d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t, unsigned); // DO NOT IMPLEMENT 60d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonpublic: 61d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // allocate space for exactly two operands 62d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t s) { 63d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return User::operator new(s, 2); 64d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 65d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson BinaryConstantExpr(unsigned Opcode, Constant *C1, Constant *C2) 66d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson : ConstantExpr(C1->getType(), Opcode, &Op<0>(), 2) { 67d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<0>() = C1; 68d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<1>() = C2; 69d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 70d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson /// Transparently provide more efficient getOperand methods. 71d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 72d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 73d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 74d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// SelectConstantExpr - This class is private to Constants.cpp, and is used 75d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// behind the scenes to implement select constant exprs. 76d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonclass SelectConstantExpr : public ConstantExpr { 77d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t, unsigned); // DO NOT IMPLEMENT 78d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonpublic: 79d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // allocate space for exactly three operands 80d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t s) { 81d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return User::operator new(s, 3); 82d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 83d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson SelectConstantExpr(Constant *C1, Constant *C2, Constant *C3) 84d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson : ConstantExpr(C2->getType(), Instruction::Select, &Op<0>(), 3) { 85d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<0>() = C1; 86d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<1>() = C2; 87d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<2>() = C3; 88d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 89d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson /// Transparently provide more efficient getOperand methods. 90d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 91d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 92d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 93d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// ExtractElementConstantExpr - This class is private to 94d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// Constants.cpp, and is used behind the scenes to implement 95d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// extractelement constant exprs. 96d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonclass ExtractElementConstantExpr : public ConstantExpr { 97d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t, unsigned); // DO NOT IMPLEMENT 98d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonpublic: 99d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // allocate space for exactly two operands 100d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t s) { 101d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return User::operator new(s, 2); 102d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 103d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson ExtractElementConstantExpr(Constant *C1, Constant *C2) 104d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson : ConstantExpr(cast<VectorType>(C1->getType())->getElementType(), 105d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Instruction::ExtractElement, &Op<0>(), 2) { 106d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<0>() = C1; 107d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<1>() = C2; 108d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 109d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson /// Transparently provide more efficient getOperand methods. 110d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 111d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 112d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 113d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// InsertElementConstantExpr - This class is private to 114d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// Constants.cpp, and is used behind the scenes to implement 115d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// insertelement constant exprs. 116d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonclass InsertElementConstantExpr : public ConstantExpr { 117d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t, unsigned); // DO NOT IMPLEMENT 118d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonpublic: 119d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // allocate space for exactly three operands 120d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t s) { 121d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return User::operator new(s, 3); 122d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 123d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson InsertElementConstantExpr(Constant *C1, Constant *C2, Constant *C3) 124d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson : ConstantExpr(C1->getType(), Instruction::InsertElement, 125d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson &Op<0>(), 3) { 126d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<0>() = C1; 127d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<1>() = C2; 128d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<2>() = C3; 129d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 130d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson /// Transparently provide more efficient getOperand methods. 131d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 132d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 133d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 134d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// ShuffleVectorConstantExpr - This class is private to 135d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// Constants.cpp, and is used behind the scenes to implement 136d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// shufflevector constant exprs. 137d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonclass ShuffleVectorConstantExpr : public ConstantExpr { 138d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t, unsigned); // DO NOT IMPLEMENT 139d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonpublic: 140d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // allocate space for exactly three operands 141d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t s) { 142d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return User::operator new(s, 3); 143d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 144d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson ShuffleVectorConstantExpr(Constant *C1, Constant *C2, Constant *C3) 145d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson : ConstantExpr(VectorType::get( 146d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson cast<VectorType>(C1->getType())->getElementType(), 147d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson cast<VectorType>(C3->getType())->getNumElements()), 148d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Instruction::ShuffleVector, 149d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson &Op<0>(), 3) { 150d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<0>() = C1; 151d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<1>() = C2; 152d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<2>() = C3; 153d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 154d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson /// Transparently provide more efficient getOperand methods. 155d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 156d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 157d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 158d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// ExtractValueConstantExpr - This class is private to 159d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// Constants.cpp, and is used behind the scenes to implement 160d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// extractvalue constant exprs. 161d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonclass ExtractValueConstantExpr : public ConstantExpr { 162d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t, unsigned); // DO NOT IMPLEMENT 163d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonpublic: 164d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // allocate space for exactly one operand 165d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t s) { 166d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return User::operator new(s, 1); 167d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 168d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson ExtractValueConstantExpr(Constant *Agg, 169d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson const SmallVector<unsigned, 4> &IdxList, 170d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson const Type *DestTy) 171d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson : ConstantExpr(DestTy, Instruction::ExtractValue, &Op<0>(), 1), 172d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Indices(IdxList) { 173d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<0>() = Agg; 174d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 175d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 176d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson /// Indices - These identify which value to extract. 177d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson const SmallVector<unsigned, 4> Indices; 178d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 179d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson /// Transparently provide more efficient getOperand methods. 180d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 181d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 182d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 183d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// InsertValueConstantExpr - This class is private to 184d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// Constants.cpp, and is used behind the scenes to implement 185d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// insertvalue constant exprs. 186d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonclass InsertValueConstantExpr : public ConstantExpr { 187d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t, unsigned); // DO NOT IMPLEMENT 188d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonpublic: 189d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // allocate space for exactly one operand 190d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t s) { 191d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return User::operator new(s, 2); 192d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 193d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson InsertValueConstantExpr(Constant *Agg, Constant *Val, 194d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson const SmallVector<unsigned, 4> &IdxList, 195d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson const Type *DestTy) 196d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson : ConstantExpr(DestTy, Instruction::InsertValue, &Op<0>(), 2), 197d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Indices(IdxList) { 198d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<0>() = Agg; 199d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<1>() = Val; 200d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 201d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 202d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson /// Indices - These identify the position for the insertion. 203d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson const SmallVector<unsigned, 4> Indices; 204d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 205d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson /// Transparently provide more efficient getOperand methods. 206d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 207d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 208d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 209d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 210d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// GetElementPtrConstantExpr - This class is private to Constants.cpp, and is 211d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson/// used behind the scenes to implement getelementpr constant exprs. 212d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonclass GetElementPtrConstantExpr : public ConstantExpr { 213d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson GetElementPtrConstantExpr(Constant *C, const std::vector<Constant*> &IdxList, 214d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson const Type *DestTy); 215d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonpublic: 216d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson static GetElementPtrConstantExpr *Create(Constant *C, 217d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson const std::vector<Constant*>&IdxList, 218d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson const Type *DestTy) { 219d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return 220d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson new(IdxList.size() + 1) GetElementPtrConstantExpr(C, IdxList, DestTy); 221d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 222d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson /// Transparently provide more efficient getOperand methods. 223d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 224d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 225d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 226d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson// CompareConstantExpr - This class is private to Constants.cpp, and is used 227d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson// behind the scenes to implement ICmp and FCmp constant expressions. This is 228d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson// needed in order to store the predicate value for these instructions. 229d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct CompareConstantExpr : public ConstantExpr { 230d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t, unsigned); // DO NOT IMPLEMENT 231d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // allocate space for exactly two operands 232d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson void *operator new(size_t s) { 233d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return User::operator new(s, 2); 234d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 235d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson unsigned short predicate; 236d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson CompareConstantExpr(const Type *ty, Instruction::OtherOps opc, 237d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson unsigned short pred, Constant* LHS, Constant* RHS) 238d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson : ConstantExpr(ty, opc, &Op<0>(), 2), predicate(pred) { 239d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<0>() = LHS; 240d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Op<1>() = RHS; 241d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 242d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson /// Transparently provide more efficient getOperand methods. 243d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value); 244d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 245d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 246d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate <> 247d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct OperandTraits<UnaryConstantExpr> : FixedNumOperandTraits<1> { 248d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 249d03eecd063a18ce0c505a87afcb04db26c035bc9Owen AndersonDEFINE_TRANSPARENT_OPERAND_ACCESSORS(UnaryConstantExpr, Value) 250d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 251d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate <> 252d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct OperandTraits<BinaryConstantExpr> : FixedNumOperandTraits<2> { 253d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 254d03eecd063a18ce0c505a87afcb04db26c035bc9Owen AndersonDEFINE_TRANSPARENT_OPERAND_ACCESSORS(BinaryConstantExpr, Value) 255d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 256d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate <> 257d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct OperandTraits<SelectConstantExpr> : FixedNumOperandTraits<3> { 258d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 259d03eecd063a18ce0c505a87afcb04db26c035bc9Owen AndersonDEFINE_TRANSPARENT_OPERAND_ACCESSORS(SelectConstantExpr, Value) 260d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 261d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate <> 262d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct OperandTraits<ExtractElementConstantExpr> : FixedNumOperandTraits<2> { 263d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 264d03eecd063a18ce0c505a87afcb04db26c035bc9Owen AndersonDEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractElementConstantExpr, Value) 265d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 266d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate <> 267d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct OperandTraits<InsertElementConstantExpr> : FixedNumOperandTraits<3> { 268d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 269d03eecd063a18ce0c505a87afcb04db26c035bc9Owen AndersonDEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertElementConstantExpr, Value) 270d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 271d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate <> 272d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct OperandTraits<ShuffleVectorConstantExpr> : FixedNumOperandTraits<3> { 273d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 274d03eecd063a18ce0c505a87afcb04db26c035bc9Owen AndersonDEFINE_TRANSPARENT_OPERAND_ACCESSORS(ShuffleVectorConstantExpr, Value) 275d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 276d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate <> 277d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct OperandTraits<ExtractValueConstantExpr> : FixedNumOperandTraits<1> { 278d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 279d03eecd063a18ce0c505a87afcb04db26c035bc9Owen AndersonDEFINE_TRANSPARENT_OPERAND_ACCESSORS(ExtractValueConstantExpr, Value) 280d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 281d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate <> 282d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct OperandTraits<InsertValueConstantExpr> : FixedNumOperandTraits<2> { 283d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 284d03eecd063a18ce0c505a87afcb04db26c035bc9Owen AndersonDEFINE_TRANSPARENT_OPERAND_ACCESSORS(InsertValueConstantExpr, Value) 285d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 286d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate <> 287d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct OperandTraits<GetElementPtrConstantExpr> : VariadicOperandTraits<1> { 288d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 289d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 290d03eecd063a18ce0c505a87afcb04db26c035bc9Owen AndersonDEFINE_TRANSPARENT_OPERAND_ACCESSORS(GetElementPtrConstantExpr, Value) 291d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 292d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 293d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate <> 294d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct OperandTraits<CompareConstantExpr> : FixedNumOperandTraits<2> { 295d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 296d03eecd063a18ce0c505a87afcb04db26c035bc9Owen AndersonDEFINE_TRANSPARENT_OPERAND_ACCESSORS(CompareConstantExpr, Value) 297d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 298d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct ExprMapKeyType { 299d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson typedef SmallVector<unsigned, 4> IndexList; 300d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 301d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson ExprMapKeyType(unsigned opc, 302d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson const std::vector<Constant*> &ops, 303d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson unsigned short pred = 0, 304d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson const IndexList &inds = IndexList()) 305d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson : opcode(opc), predicate(pred), operands(ops), indices(inds) {} 306d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson uint16_t opcode; 307d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson uint16_t predicate; 308d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson std::vector<Constant*> operands; 309d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson IndexList indices; 310d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson bool operator==(const ExprMapKeyType& that) const { 311d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return this->opcode == that.opcode && 312d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson this->predicate == that.predicate && 313d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson this->operands == that.operands && 314d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson this->indices == that.indices; 315d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 316d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson bool operator<(const ExprMapKeyType & that) const { 317d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return this->opcode < that.opcode || 318d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson (this->opcode == that.opcode && this->predicate < that.predicate) || 319d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson (this->opcode == that.opcode && this->predicate == that.predicate && 320d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson this->operands < that.operands) || 321d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson (this->opcode == that.opcode && this->predicate == that.predicate && 322d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson this->operands == that.operands && this->indices < that.indices); 323d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 324d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 325d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson bool operator!=(const ExprMapKeyType& that) const { 326d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return !(*this == that); 327d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 328d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 329d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 330eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// The number of operands for each ConstantCreator::create method is 331eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// determined by the ConstantTraits template. 332eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// ConstantCreator - A class that is used to create constants by 333eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// ValueMap*. This class should be partially specialized if there is 334eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// something strange that needs to be done to interface to the ctor for the 335eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// constant. 336eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// 337eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersontemplate<typename T, typename Alloc> 338d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct ConstantTraits< std::vector<T, Alloc> > { 339eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson static unsigned uses(const std::vector<T, Alloc>& v) { 340eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return v.size(); 341eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 342eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson}; 343eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 344eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersontemplate<class ConstantClass, class TypeClass, class ValType> 345d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct ConstantCreator { 346eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson static ConstantClass *create(const TypeClass *Ty, const ValType &V) { 347eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return new(ConstantTraits<ValType>::uses(V)) ConstantClass(Ty, V); 348eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 349eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson}; 350eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 351eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersontemplate<class ConstantClass, class TypeClass> 352d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct ConvertConstantType { 353eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson static void convert(ConstantClass *OldC, const TypeClass *NewTy) { 354eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson llvm_unreachable("This type cannot be converted!"); 355eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 356eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson}; 357eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 358d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate<> 359d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct ConstantCreator<ConstantExpr, Type, ExprMapKeyType> { 360d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson static ConstantExpr *create(const Type *Ty, const ExprMapKeyType &V, 361d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson unsigned short pred = 0) { 362d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson if (Instruction::isCast(V.opcode)) 363d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return new UnaryConstantExpr(V.opcode, V.operands[0], Ty); 364d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson if ((V.opcode >= Instruction::BinaryOpsBegin && 365d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson V.opcode < Instruction::BinaryOpsEnd)) 366d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return new BinaryConstantExpr(V.opcode, V.operands[0], V.operands[1]); 367d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson if (V.opcode == Instruction::Select) 368d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return new SelectConstantExpr(V.operands[0], V.operands[1], 369d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson V.operands[2]); 370d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson if (V.opcode == Instruction::ExtractElement) 371d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return new ExtractElementConstantExpr(V.operands[0], V.operands[1]); 372d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson if (V.opcode == Instruction::InsertElement) 373d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return new InsertElementConstantExpr(V.operands[0], V.operands[1], 374d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson V.operands[2]); 375d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson if (V.opcode == Instruction::ShuffleVector) 376d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return new ShuffleVectorConstantExpr(V.operands[0], V.operands[1], 377d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson V.operands[2]); 378d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson if (V.opcode == Instruction::InsertValue) 379d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return new InsertValueConstantExpr(V.operands[0], V.operands[1], 380d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson V.indices, Ty); 381d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson if (V.opcode == Instruction::ExtractValue) 382d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return new ExtractValueConstantExpr(V.operands[0], V.indices, Ty); 383d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson if (V.opcode == Instruction::GetElementPtr) { 384d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson std::vector<Constant*> IdxList(V.operands.begin()+1, V.operands.end()); 385d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return GetElementPtrConstantExpr::Create(V.operands[0], IdxList, Ty); 386d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 387d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 388d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // The compare instructions are weird. We have to encode the predicate 389d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // value and it is combined with the instruction opcode by multiplying 390d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // the opcode by one hundred. We must decode this to get the predicate. 391d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson if (V.opcode == Instruction::ICmp) 392d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return new CompareConstantExpr(Ty, Instruction::ICmp, V.predicate, 393d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson V.operands[0], V.operands[1]); 394d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson if (V.opcode == Instruction::FCmp) 395d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return new CompareConstantExpr(Ty, Instruction::FCmp, V.predicate, 396d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson V.operands[0], V.operands[1]); 397d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson llvm_unreachable("Invalid ConstantExpr!"); 398d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson return 0; 399d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 400d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 401d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 402d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersontemplate<> 403d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct ConvertConstantType<ConstantExpr, Type> { 404d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson static void convert(ConstantExpr *OldC, const Type *NewTy) { 405d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson Constant *New; 406d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson switch (OldC->getOpcode()) { 407d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::Trunc: 408d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::ZExt: 409d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::SExt: 410d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::FPTrunc: 411d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::FPExt: 412d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::UIToFP: 413d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::SIToFP: 414d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::FPToUI: 415d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::FPToSI: 416d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::PtrToInt: 417d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::IntToPtr: 418d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::BitCast: 419d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson New = ConstantExpr::getCast(OldC->getOpcode(), OldC->getOperand(0), 420d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson NewTy); 421d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson break; 422d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::Select: 423d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson New = ConstantExpr::getSelectTy(NewTy, OldC->getOperand(0), 424d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson OldC->getOperand(1), 425d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson OldC->getOperand(2)); 426d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson break; 427d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson default: 428d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson assert(OldC->getOpcode() >= Instruction::BinaryOpsBegin && 429d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson OldC->getOpcode() < Instruction::BinaryOpsEnd); 430d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson New = ConstantExpr::getTy(NewTy, OldC->getOpcode(), OldC->getOperand(0), 431d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson OldC->getOperand(1)); 432d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson break; 433d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson case Instruction::GetElementPtr: 434d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson // Make everyone now use a constant of the new type... 435d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson std::vector<Value*> Idx(OldC->op_begin()+1, OldC->op_end()); 436d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson New = ConstantExpr::getGetElementPtrTy(NewTy, OldC->getOperand(0), 437d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson &Idx[0], Idx.size()); 438d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson break; 439d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 440d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 441d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson assert(New != OldC && "Didn't replace constant??"); 442d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson OldC->uncheckedReplaceAllUsesWith(New); 443d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson OldC->destroyConstant(); // This constant is now dead, destroy it. 444d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson } 445d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson}; 446d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 447eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson// ConstantAggregateZero does not take extra "value" argument... 448eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersontemplate<class ValType> 449eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersonstruct ConstantCreator<ConstantAggregateZero, Type, ValType> { 450eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson static ConstantAggregateZero *create(const Type *Ty, const ValType &V){ 451eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return new ConstantAggregateZero(Ty); 452eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 453eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson}; 454eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 455eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersontemplate<> 4567e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Andersonstruct ConvertConstantType<ConstantVector, VectorType> { 4577e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson static void convert(ConstantVector *OldC, const VectorType *NewTy) { 4587e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson // Make everyone now use a constant of the new type... 4597e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson std::vector<Constant*> C; 4607e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i) 4617e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson C.push_back(cast<Constant>(OldC->getOperand(i))); 4627e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson Constant *New = ConstantVector::get(NewTy, C); 4637e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson assert(New != OldC && "Didn't replace constant??"); 4647e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson OldC->uncheckedReplaceAllUsesWith(New); 4657e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson OldC->destroyConstant(); // This constant is now dead, destroy it. 4667e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson } 4677e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson}; 4687e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson 4697e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Andersontemplate<> 470eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersonstruct ConvertConstantType<ConstantAggregateZero, Type> { 471eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson static void convert(ConstantAggregateZero *OldC, const Type *NewTy) { 472eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Make everyone now use a constant of the new type... 4739e9a0d5fc26878e51a58a8b57900fcbf952c2691Owen Anderson Constant *New = ConstantAggregateZero::get(NewTy); 474eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(New != OldC && "Didn't replace constant??"); 475eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson OldC->uncheckedReplaceAllUsesWith(New); 476eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson OldC->destroyConstant(); // This constant is now dead, destroy it. 477eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 478eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson}; 479eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 480eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersontemplate<> 481eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersonstruct ConvertConstantType<ConstantArray, ArrayType> { 482eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson static void convert(ConstantArray *OldC, const ArrayType *NewTy) { 483eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Make everyone now use a constant of the new type... 484eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson std::vector<Constant*> C; 485eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i) 486eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson C.push_back(cast<Constant>(OldC->getOperand(i))); 4871fd7096407d5e598ed3366a1141548e71273f1c5Owen Anderson Constant *New = ConstantArray::get(NewTy, C); 488eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(New != OldC && "Didn't replace constant??"); 489eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson OldC->uncheckedReplaceAllUsesWith(New); 490eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson OldC->destroyConstant(); // This constant is now dead, destroy it. 491eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 492eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson}; 493eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 494eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersontemplate<> 495eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersonstruct ConvertConstantType<ConstantStruct, StructType> { 496eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson static void convert(ConstantStruct *OldC, const StructType *NewTy) { 497eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Make everyone now use a constant of the new type... 498eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson std::vector<Constant*> C; 499eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson for (unsigned i = 0, e = OldC->getNumOperands(); i != e; ++i) 500eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson C.push_back(cast<Constant>(OldC->getOperand(i))); 5018fa3338ed2400c1352b137613d2c2c70d1ead695Owen Anderson Constant *New = ConstantStruct::get(NewTy, C); 502eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(New != OldC && "Didn't replace constant??"); 503eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 504eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson OldC->uncheckedReplaceAllUsesWith(New); 505eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson OldC->destroyConstant(); // This constant is now dead, destroy it. 506eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 507eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson}; 508eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 5097e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson// ConstantPointerNull does not take extra "value" argument... 5107e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Andersontemplate<class ValType> 5117e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Andersonstruct ConstantCreator<ConstantPointerNull, PointerType, ValType> { 5127e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson static ConstantPointerNull *create(const PointerType *Ty, const ValType &V){ 5137e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson return new ConstantPointerNull(Ty); 5147e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson } 5157e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson}; 5167e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson 517eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersontemplate<> 5187e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Andersonstruct ConvertConstantType<ConstantPointerNull, PointerType> { 5197e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson static void convert(ConstantPointerNull *OldC, const PointerType *NewTy) { 520eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Make everyone now use a constant of the new type... 5217e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson Constant *New = ConstantPointerNull::get(NewTy); 522eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(New != OldC && "Didn't replace constant??"); 523eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson OldC->uncheckedReplaceAllUsesWith(New); 5247e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson OldC->destroyConstant(); // This constant is now dead, destroy it. 5257e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson } 5267e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson}; 5277e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson 5287e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson// UndefValue does not take extra "value" argument... 5297e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Andersontemplate<class ValType> 5307e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Andersonstruct ConstantCreator<UndefValue, Type, ValType> { 5317e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson static UndefValue *create(const Type *Ty, const ValType &V) { 5327e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson return new UndefValue(Ty); 5337e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson } 5347e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson}; 5357e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson 5367e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Andersontemplate<> 5377e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Andersonstruct ConvertConstantType<UndefValue, Type> { 5387e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson static void convert(UndefValue *OldC, const Type *NewTy) { 5397e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson // Make everyone now use a constant of the new type. 5407e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson Constant *New = UndefValue::get(NewTy); 5417e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson assert(New != OldC && "Didn't replace constant??"); 5427e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson OldC->uncheckedReplaceAllUsesWith(New); 5437e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson OldC->destroyConstant(); // This constant is now dead, destroy it. 544eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 545eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson}; 546eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 547eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersontemplate<class ValType, class TypeClass, class ConstantClass, 548eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson bool HasLargeKey = false /*true for arrays and structs*/ > 549eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersonclass ValueMap : public AbstractTypeUser { 550eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersonpublic: 551eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typedef std::pair<const Type*, ValType> MapKey; 552eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typedef std::map<MapKey, Constant *> MapTy; 553eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typedef std::map<Constant*, typename MapTy::iterator> InverseMapTy; 554eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typedef std::map<const Type*, typename MapTy::iterator> AbstractTypeMapTy; 555eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersonprivate: 556eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// Map - This is the main map from the element descriptor to the Constants. 557eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// This is the primary way we avoid creating two of the same shape 558eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// constant. 559eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson MapTy Map; 560eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 561eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// InverseMap - If "HasLargeKey" is true, this contains an inverse mapping 562eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// from the constants to their element in Map. This is important for 563eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// removal of constants from the array, which would otherwise have to scan 564eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// through the map with very large keys. 565eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson InverseMapTy InverseMap; 566eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 567eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// AbstractTypeMap - Map for abstract type constants. 568eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// 569eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson AbstractTypeMapTy AbstractTypeMap; 570eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 571eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// ValueMapLock - Mutex for this map. 572eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson sys::SmartMutex<true> ValueMapLock; 573eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 574eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersonpublic: 575eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // NOTE: This function is not locked. It is the caller's responsibility 576eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // to enforce proper synchronization. 577eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename MapTy::iterator map_end() { return Map.end(); } 578eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 579eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// InsertOrGetItem - Return an iterator for the specified element. 580eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// If the element exists in the map, the returned iterator points to the 581eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// entry and Exists=true. If not, the iterator points to the newly 582eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// inserted entry and returns Exists=false. Newly inserted entries have 583eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// I->second == 0, and should be filled in. 584eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// NOTE: This function is not locked. It is the caller's responsibility 585eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // to enforce proper synchronization. 586eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename MapTy::iterator InsertOrGetItem(std::pair<MapKey, Constant *> 587eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson &InsertVal, 588eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson bool &Exists) { 589eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson std::pair<typename MapTy::iterator, bool> IP = Map.insert(InsertVal); 590eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson Exists = !IP.second; 591eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return IP.first; 592eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 593eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 594eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersonprivate: 595eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename MapTy::iterator FindExistingElement(ConstantClass *CP) { 596eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (HasLargeKey) { 597eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename InverseMapTy::iterator IMI = InverseMap.find(CP); 598eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(IMI != InverseMap.end() && IMI->second != Map.end() && 599eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson IMI->second->second == CP && 600eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson "InverseMap corrupt!"); 601eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return IMI->second; 602eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 603eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 604eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename MapTy::iterator I = 605eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson Map.find(MapKey(static_cast<const TypeClass*>(CP->getRawType()), 606eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson getValType(CP))); 607eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (I == Map.end() || I->second != CP) { 608eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // FIXME: This should not use a linear scan. If this gets to be a 609eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // performance problem, someone should look at this. 610eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson for (I = Map.begin(); I != Map.end() && I->second != CP; ++I) 611eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /* empty */; 612eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 613eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return I; 614eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 615eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 616eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantClass* Create(const TypeClass *Ty, const ValType &V, 617eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename MapTy::iterator I) { 618eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantClass* Result = 619eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantCreator<ConstantClass,TypeClass,ValType>::create(Ty, V); 620eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 621eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(Result->getType() == Ty && "Type specified is not correct!"); 622eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson I = Map.insert(I, std::make_pair(MapKey(Ty, V), Result)); 623eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 624eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (HasLargeKey) // Remember the reverse mapping if needed. 625eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson InverseMap.insert(std::make_pair(Result, I)); 626eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 627eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // If the type of the constant is abstract, make sure that an entry 628eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // exists for it in the AbstractTypeMap. 629eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (Ty->isAbstract()) { 630eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename AbstractTypeMapTy::iterator TI = 631eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson AbstractTypeMap.find(Ty); 632eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 633eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (TI == AbstractTypeMap.end()) { 634eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Add ourselves to the ATU list of the type. 635eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson cast<DerivedType>(Ty)->addAbstractTypeUser(this); 636eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 637eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson AbstractTypeMap.insert(TI, std::make_pair(Ty, I)); 638eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 639eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 640eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 641eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return Result; 642eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 643eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Andersonpublic: 644eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 645eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// getOrCreate - Return the specified constant from the map, creating it if 646eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// necessary. 647eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantClass *getOrCreate(const TypeClass *Ty, const ValType &V) { 648eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson sys::SmartScopedLock<true> Lock(ValueMapLock); 649eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson MapKey Lookup(Ty, V); 650eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConstantClass* Result = 0; 651eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 652eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename MapTy::iterator I = Map.find(Lookup); 653eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Is it in the map? 654eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (I != Map.end()) 655eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson Result = static_cast<ConstantClass *>(I->second); 656eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 657eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (!Result) { 658eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // If no preexisting value, create one now... 659eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson Result = Create(Ty, V, I); 660eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 661eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 662eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson return Result; 663eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 664eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 665eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson void remove(ConstantClass *CP) { 666eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson sys::SmartScopedLock<true> Lock(ValueMapLock); 667eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename MapTy::iterator I = FindExistingElement(CP); 668eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(I != Map.end() && "Constant not found in constant table!"); 669eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(I->second == CP && "Didn't find correct element?"); 670eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 671eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (HasLargeKey) // Remember the reverse mapping if needed. 672eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson InverseMap.erase(CP); 673eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 674eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Now that we found the entry, make sure this isn't the entry that 675eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // the AbstractTypeMap points to. 676eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson const TypeClass *Ty = static_cast<const TypeClass *>(I->first.first); 677eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (Ty->isAbstract()) { 678eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(AbstractTypeMap.count(Ty) && 679eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson "Abstract type not in AbstractTypeMap?"); 680eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename MapTy::iterator &ATMEntryIt = AbstractTypeMap[Ty]; 681eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (ATMEntryIt == I) { 682eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Yes, we are removing the representative entry for this type. 683eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // See if there are any other entries of the same type. 684eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename MapTy::iterator TmpIt = ATMEntryIt; 685eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 686eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // First check the entry before this one... 687eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (TmpIt != Map.begin()) { 688eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson --TmpIt; 689eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (TmpIt->first.first != Ty) // Not the same type, move back... 690eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ++TmpIt; 691eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 692eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 693eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // If we didn't find the same type, try to move forward... 694eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (TmpIt == ATMEntryIt) { 695eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ++TmpIt; 696eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (TmpIt == Map.end() || TmpIt->first.first != Ty) 697eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson --TmpIt; // No entry afterwards with the same type 698eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 699eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 700eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // If there is another entry in the map of the same abstract type, 701eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // update the AbstractTypeMap entry now. 702eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (TmpIt != ATMEntryIt) { 703eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ATMEntryIt = TmpIt; 704eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } else { 705eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Otherwise, we are removing the last instance of this type 706eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // from the table. Remove from the ATM, and from user list. 707eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson cast<DerivedType>(Ty)->removeAbstractTypeUser(this); 708eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson AbstractTypeMap.erase(Ty); 709eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 710eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 711eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 712eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 713eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson Map.erase(I); 714eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 715eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 716eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 717eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// MoveConstantToNewSlot - If we are about to change C to be the element 718eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// specified by I, update our internal data structures to reflect this 719eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// fact. 720eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// NOTE: This function is not locked. It is the responsibility of the 721eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson /// caller to enforce proper synchronization if using this method. 722eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson void MoveConstantToNewSlot(ConstantClass *C, typename MapTy::iterator I) { 723eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // First, remove the old location of the specified constant in the map. 724eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename MapTy::iterator OldI = FindExistingElement(C); 725eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(OldI != Map.end() && "Constant not found in constant table!"); 726eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(OldI->second == C && "Didn't find correct element?"); 727eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 728eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // If this constant is the representative element for its abstract type, 729eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // update the AbstractTypeMap so that the representative element is I. 730eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (C->getType()->isAbstract()) { 731eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename AbstractTypeMapTy::iterator ATI = 732eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson AbstractTypeMap.find(C->getType()); 733eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(ATI != AbstractTypeMap.end() && 734eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson "Abstract type not in AbstractTypeMap?"); 735eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (ATI->second == OldI) 736eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ATI->second = I; 737eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 738eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 739eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Remove the old entry from the map. 740eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson Map.erase(OldI); 741eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 742eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Update the inverse map so that we know that this constant is now 743eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // located at descriptor I. 744eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson if (HasLargeKey) { 745eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(I->second == C && "Bad inversemap entry!"); 746eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson InverseMap[C] = I; 747eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 748eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 749eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 750eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson void refineAbstractType(const DerivedType *OldTy, const Type *NewTy) { 751eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson sys::SmartScopedLock<true> Lock(ValueMapLock); 752eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson typename AbstractTypeMapTy::iterator I = 753eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson AbstractTypeMap.find(cast<Type>(OldTy)); 754eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 755eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson assert(I != AbstractTypeMap.end() && 756eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson "Abstract type not in AbstractTypeMap?"); 757eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 758eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // Convert a constant at a time until the last one is gone. The last one 759eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // leaving will remove() itself, causing the AbstractTypeMapEntry to be 760eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // eliminated eventually. 761eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson do { 762eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ConvertConstantType<ConstantClass, 763eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson TypeClass>::convert( 764eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson static_cast<ConstantClass *>(I->second->second), 765eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson cast<TypeClass>(NewTy)); 766eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 767eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson I = AbstractTypeMap.find(cast<Type>(OldTy)); 768eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } while (I != AbstractTypeMap.end()); 769eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 770eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 771eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // If the type became concrete without being refined to any other existing 772eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson // type, we just remove ourselves from the ATU list. 773eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson void typeBecameConcrete(const DerivedType *AbsTy) { 774eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson AbsTy->removeAbstractTypeUser(this); 775eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 776eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 777eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson void dump() const { 778eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson DOUT << "Constant.cpp: ValueMap\n"; 779eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson } 780eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson}; 781eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 782eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson 783001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Andersonclass ConstantInt; 784914e50c841bbc248ab94144c11813b5785b1292dOwen Andersonclass ConstantFP; 785aad3fb7362aff151e97ad457005ea3f2872fe868Owen Andersonclass MDString; 786ce032b483ca96093b84f69178cdb2d047e124332Owen Andersonclass MDNode; 787001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Andersonclass LLVMContext; 788001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Andersonclass Type; 789ce032b483ca96093b84f69178cdb2d047e124332Owen Andersonclass Value; 790001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson 791001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Andersonstruct DenseMapAPIntKeyInfo { 792001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson struct KeyTy { 793001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson APInt val; 794001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson const Type* type; 795001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson KeyTy(const APInt& V, const Type* Ty) : val(V), type(Ty) {} 796001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson KeyTy(const KeyTy& that) : val(that.val), type(that.type) {} 797001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson bool operator==(const KeyTy& that) const { 798001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson return type == that.type && this->val == that.val; 799001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson } 800001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson bool operator!=(const KeyTy& that) const { 801001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson return !this->operator==(that); 802001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson } 803001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson }; 804001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson static inline KeyTy getEmptyKey() { return KeyTy(APInt(1,0), 0); } 805001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson static inline KeyTy getTombstoneKey() { return KeyTy(APInt(1,1), 0); } 806001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson static unsigned getHashValue(const KeyTy &Key) { 807001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson return DenseMapInfo<void*>::getHashValue(Key.type) ^ 808001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson Key.val.getHashValue(); 809001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson } 810001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) { 811001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson return LHS == RHS; 812001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson } 813001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson static bool isPod() { return false; } 814001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson}; 815001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson 816914e50c841bbc248ab94144c11813b5785b1292dOwen Andersonstruct DenseMapAPFloatKeyInfo { 817914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson struct KeyTy { 818914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson APFloat val; 819914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson KeyTy(const APFloat& V) : val(V){} 820914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson KeyTy(const KeyTy& that) : val(that.val) {} 821914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson bool operator==(const KeyTy& that) const { 822914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson return this->val.bitwiseIsEqual(that.val); 823914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson } 824914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson bool operator!=(const KeyTy& that) const { 825914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson return !this->operator==(that); 826914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson } 827914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson }; 828914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson static inline KeyTy getEmptyKey() { 829914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson return KeyTy(APFloat(APFloat::Bogus,1)); 830914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson } 831914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson static inline KeyTy getTombstoneKey() { 832914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson return KeyTy(APFloat(APFloat::Bogus,2)); 833914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson } 834914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson static unsigned getHashValue(const KeyTy &Key) { 835914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson return Key.val.getHashValue(); 836914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson } 837914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson static bool isEqual(const KeyTy &LHS, const KeyTy &RHS) { 838914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson return LHS == RHS; 839914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson } 840914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson static bool isPod() { return false; } 841914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson}; 842914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson 843d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonstruct LLVMContextImpl { 844001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson sys::SmartRWMutex<true> ConstantsLock; 845001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson 846001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson typedef DenseMap<DenseMapAPIntKeyInfo::KeyTy, ConstantInt*, 847001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson DenseMapAPIntKeyInfo> IntMapTy; 848001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson IntMapTy IntConstants; 849001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson 850914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson typedef DenseMap<DenseMapAPFloatKeyInfo::KeyTy, ConstantFP*, 851914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson DenseMapAPFloatKeyInfo> FPMapTy; 852914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson FPMapTy FPConstants; 853914e50c841bbc248ab94144c11813b5785b1292dOwen Anderson 854aad3fb7362aff151e97ad457005ea3f2872fe868Owen Anderson StringMap<MDString*> MDStringCache; 855aad3fb7362aff151e97ad457005ea3f2872fe868Owen Anderson 856ce032b483ca96093b84f69178cdb2d047e124332Owen Anderson FoldingSet<MDNode> MDNodeSet; 857ce032b483ca96093b84f69178cdb2d047e124332Owen Anderson 858eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ValueMap<char, Type, ConstantAggregateZero> AggZeroConstants; 859822ccd9974a17979d2cb9c6c118f94549055b7d4Owen Anderson 860822ccd9974a17979d2cb9c6c118f94549055b7d4Owen Anderson typedef ValueMap<std::vector<Constant*>, ArrayType, 861822ccd9974a17979d2cb9c6c118f94549055b7d4Owen Anderson ConstantArray, true /*largekey*/> ArrayConstantsTy; 862eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson ArrayConstantsTy ArrayConstants; 86316e298f98024bcff5c7219a96cac216114c30dadOwen Anderson 864006c77df8cc7f6a9dac575600b797b8ba32b29ebOwen Anderson typedef ValueMap<std::vector<Constant*>, StructType, 865006c77df8cc7f6a9dac575600b797b8ba32b29ebOwen Anderson ConstantStruct, true /*largekey*/> StructConstantsTy; 866eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson StructConstantsTy StructConstants; 867006c77df8cc7f6a9dac575600b797b8ba32b29ebOwen Anderson 8685bd68393ed87bcedc53f5998f1af9c906f5a1b4eOwen Anderson typedef ValueMap<std::vector<Constant*>, VectorType, 8695bd68393ed87bcedc53f5998f1af9c906f5a1b4eOwen Anderson ConstantVector> VectorConstantsTy; 870eed707b1e6097aac2bb6b3d47271f6300ace7f2eOwen Anderson VectorConstantsTy VectorConstants; 8715bd68393ed87bcedc53f5998f1af9c906f5a1b4eOwen Anderson 8727e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson ValueMap<char, PointerType, ConstantPointerNull> NullPtrConstants; 8737e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson 8747e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson ValueMap<char, Type, UndefValue> UndefValueConstants; 8757e3142b0126abc86dc4da350e8b84b001c3eeddeOwen Anderson 876d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson ValueMap<ExprMapKeyType, Type, ConstantExpr> ExprConstants; 877d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson 878001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson LLVMContext &Context; 879f53c371983908f02678b0e12c5d18466dcc70ffdOwen Anderson ConstantInt *TheTrueVal; 880f53c371983908f02678b0e12c5d18466dcc70ffdOwen Anderson ConstantInt *TheFalseVal; 881f53c371983908f02678b0e12c5d18466dcc70ffdOwen Anderson 882d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Anderson LLVMContextImpl(LLVMContext &C); 883d03eecd063a18ce0c505a87afcb04db26c035bc9Owen Andersonprivate: 884001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson LLVMContextImpl(); 885001dbfebcbbded8c8e74b19e838b50da2b6c6fb5Owen Anderson LLVMContextImpl(const LLVMContextImpl&); 8862bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson}; 8872bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson 8882bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson} 8892bc29dc0bcb3c1441477a062e4a5cffff175c8caOwen Anderson 8905217007006e91fa4bbfe88fde5149f5db293b247Owen Anderson#endif 891