Revert the ConstantInt constructors back to their 2.5 forms where possible, thanks...

[oota-llvm.git] / lib / VMCore / LLVMContext.cpp

diff --git a/lib/VMCore/LLVMContext.cpp b/lib/VMCore/LLVMContext.cpp
index 5e009ea6dffef65dfc1894d98bcb5ac66dcccb8d..db81c61ace04e8a507b08e35dca780ca69787d7e 100644 (file)
--- a/lib/VMCore/LLVMContext.cpp
+++ b/lib/VMCore/LLVMContext.cpp
@@ -39,7 +39,7 @@ static const uint64_t zero[2] = {0, 0};
 Constant* LLVMContext::getNullValue(const Type* Ty) {
   switch (Ty->getTypeID()) {
   case Type::IntegerTyID:
-    return getConstantInt(Ty, 0);
+    return ConstantInt::get(Ty, 0);
   case Type::FloatTyID:
     return getConstantFP(APFloat(APInt(32, 0)));
   case Type::DoubleTyID:
@@ -65,7 +65,7 @@ Constant* LLVMContext::getNullValue(const Type* Ty) {
 
 Constant* LLVMContext::getAllOnesValue(const Type* Ty) {
   if (const IntegerType* ITy = dyn_cast<IntegerType>(Ty))
-    return getConstantInt(APInt::getAllOnesValue(ITy->getBitWidth()));
+    return ConstantInt::get(*this, APInt::getAllOnesValue(ITy->getBitWidth()));
   
   std::vector<Constant*> Elts;
   const VectorType* VTy = cast<VectorType>(Ty);
@@ -92,51 +92,6 @@ ConstantInt* LLVMContext::getFalse() {
   return pImpl->getFalse();
 }
 
-Constant* LLVMContext::getConstantInt(const Type* Ty, uint64_t V,
-                                         bool isSigned) {
-  Constant *C = getConstantInt(cast<IntegerType>(Ty->getScalarType()),
-                               V, isSigned);
-
-  // For vectors, broadcast the value.
-  if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
-    return
-      getConstantVector(std::vector<Constant *>(VTy->getNumElements(), C));
-
-  return C;
-}
-
-
-ConstantInt* LLVMContext::getConstantInt(const IntegerType* Ty, uint64_t V,
-                                         bool isSigned) {
-  return getConstantInt(APInt(Ty->getBitWidth(), V, isSigned));
-}
-
-ConstantInt* LLVMContext::getConstantIntSigned(const IntegerType* Ty,
-                                               int64_t V) {
-  return getConstantInt(Ty, V, true);
-}
-
-Constant *LLVMContext::getConstantIntSigned(const Type *Ty, int64_t V) {
-  return getConstantInt(Ty, V, true);
-}
-
-ConstantInt* LLVMContext::getConstantInt(const APInt& V) {
-  return pImpl->getConstantInt(V);
-}
-
-Constant* LLVMContext::getConstantInt(const Type* Ty, const APInt& V) {
-  ConstantInt *C = getConstantInt(V);
-  assert(C->getType() == Ty->getScalarType() &&
-         "ConstantInt type doesn't match the type implied by its value!");
-
-  // For vectors, broadcast the value.
-  if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
-    return
-      getConstantVector(std::vector<Constant *>(VTy->getNumElements(), C));
-
-  return C;
-}
-
 // ConstantPointerNull accessors.
 ConstantPointerNull* LLVMContext::getConstantPointerNull(const PointerType* T) {
   return ConstantPointerNull::get(T);
@@ -146,7 +101,7 @@ ConstantPointerNull* LLVMContext::getConstantPointerNull(const PointerType* T) {
 // ConstantStruct accessors.
 Constant* LLVMContext::getConstantStruct(const StructType* T,
                                          const std::vector<Constant*>& V) {
-  return ConstantStruct::get(T, V);
+  return pImpl->getConstantStruct(T, V);
 }
 
 Constant* LLVMContext::getConstantStruct(const std::vector<Constant*>& V,
@@ -167,14 +122,14 @@ Constant* LLVMContext::getConstantStruct(Constant* const *Vals,
 
 // ConstantAggregateZero accessors.
 ConstantAggregateZero* LLVMContext::getConstantAggregateZero(const Type* Ty) {
-  return ConstantAggregateZero::get(Ty);
+  return pImpl->getConstantAggregateZero(Ty);
 }
 
 
 // ConstantArray accessors.
 Constant* LLVMContext::getConstantArray(const ArrayType* T,
                                         const std::vector<Constant*>& V) {
-  return ConstantArray::get(T, V);
+  return pImpl->getConstantArray(T, V);
 }
 
 Constant* LLVMContext::getConstantArray(const ArrayType* T,
@@ -194,11 +149,11 @@ Constant* LLVMContext::getConstantArray(const std::string& Str,
                                         bool AddNull) {
   std::vector<Constant*> ElementVals;
   for (unsigned i = 0; i < Str.length(); ++i)
-    ElementVals.push_back(getConstantInt(Type::Int8Ty, Str[i]));
+    ElementVals.push_back(ConstantInt::get(Type::Int8Ty, Str[i]));
 
   // Add a null terminator to the string...
   if (AddNull) {
-    ElementVals.push_back(getConstantInt(Type::Int8Ty, 0));
+    ElementVals.push_back(ConstantInt::get(Type::Int8Ty, 0));
   }
 
   ArrayType *ATy = getArrayType(Type::Int8Ty, ElementVals.size());
@@ -302,8 +257,8 @@ Constant* LLVMContext::getConstantExprAlignOf(const Type* Ty) {
   // alignof is implemented as: (i64) gep ({i8,Ty}*)null, 0, 1
   const Type *AligningTy = getStructType(Type::Int8Ty, Ty, NULL);
   Constant *NullPtr = getNullValue(AligningTy->getPointerTo());
-  Constant *Zero = getConstantInt(Type::Int32Ty, 0);
-  Constant *One = getConstantInt(Type::Int32Ty, 1);
+  Constant *Zero = ConstantInt::get(Type::Int32Ty, 0);
+  Constant *One = ConstantInt::get(Type::Int32Ty, 1);
   Constant *Indices[2] = { Zero, One };
   Constant *GEP = getConstantExprGetElementPtr(NullPtr, Indices, 2);
   return getConstantExprCast(Instruction::PtrToInt, GEP, Type::Int32Ty);
@@ -463,7 +418,7 @@ Constant* LLVMContext::getConstantExprInsertValue(Constant* Agg, Constant* Val,
 
 Constant* LLVMContext::getConstantExprSizeOf(const Type* Ty) {
   // sizeof is implemented as: (i64) gep (Ty*)null, 1
-  Constant *GEPIdx = getConstantInt(Type::Int32Ty, 1);
+  Constant *GEPIdx = ConstantInt::get(Type::Int32Ty, 1);
   Constant *GEP = getConstantExprGetElementPtr(
                             getNullValue(getPointerTypeUnqual(Ty)), &GEPIdx, 1);
   return getConstantExprCast(Instruction::PtrToInt, GEP, Type::Int64Ty);
@@ -531,7 +486,7 @@ ConstantFP* LLVMContext::getConstantFPNegativeZero(const Type* Ty) {
 // ConstantVector accessors.
 Constant* LLVMContext::getConstantVector(const VectorType* T,
                             const std::vector<Constant*>& V) {
-  return ConstantVector::get(T, V);
+  return pImpl->getConstantVector(T, V);
 }
 
 Constant* LLVMContext::getConstantVector(const std::vector<Constant*>& V) {
@@ -551,12 +506,12 @@ MDNode* LLVMContext::getMDNode(Value* const* Vals, unsigned NumVals) {
 }
 
 // MDString accessors
-MDString* LLVMContext::getMDString(const char *StrBegin, const char *StrEnd) {
-  return pImpl->getMDString(StrBegin, StrEnd);
+MDString* LLVMContext::getMDString(const char *StrBegin, unsigned StrLength) {
+  return pImpl->getMDString(StrBegin, StrLength);
 }
 
 MDString* LLVMContext::getMDString(const std::string &Str) {
-  return getMDString(Str.data(), Str.data()+Str.size());
+  return getMDString(Str.data(), Str.size());
 }
 
 // FunctionType accessors
@@ -649,3 +604,29 @@ void LLVMContext::erase(MDString *M) {
 void LLVMContext::erase(MDNode *M) {
   pImpl->erase(M);
 }
+
+void LLVMContext::erase(ConstantAggregateZero *Z) {
+  pImpl->erase(Z);
+}
+
+void LLVMContext::erase(ConstantArray *C) {
+  pImpl->erase(C);
+}
+
+void LLVMContext::erase(ConstantStruct *S) {
+  pImpl->erase(S);
+}
+
+void LLVMContext::erase(ConstantVector *V) {
+  pImpl->erase(V);
+}
+
+Constant *LLVMContext::replaceUsesOfWithOnConstant(ConstantArray *CA,
+                                               Value *From, Value *To, Use *U) {
+  return pImpl->replaceUsesOfWithOnConstant(CA, From, To, U);
+}
+
+Constant *LLVMContext::replaceUsesOfWithOnConstant(ConstantStruct *CS,
+                                               Value *From, Value *To, Use *U) {
+  return pImpl->replaceUsesOfWithOnConstant(CS, From, To, U);
+}