Update for LLVM API change.

llvm-svn: 77722

clang/lib/CodeGen/CGBlocks.cpp

@@ -501,7 +501,7 @@ BlockModule::GetAddrOfGlobalBlock(const BlockExpr *BE, const char * n) {
   llvm::Constant *DescriptorFields[2];
 
   // Reserved
-  DescriptorFields[0] = getModule().getContext().getNullValue(UnsignedLongTy);
+  DescriptorFields[0] = llvm::Constant::getNullValue(UnsignedLongTy);
 
   // Block literal size. For global blocks we just use the size of the generic
   // block literal struct.
@@ -543,7 +543,7 @@ BlockModule::GetAddrOfGlobalBlock(const BlockExpr *BE, const char * n) {
     llvm::ConstantInt::get(IntTy, BLOCK_IS_GLOBAL | BLOCK_HAS_DESCRIPTOR);
 
   // Reserved
-  LiteralFields[2] = getModule().getContext().getNullValue(IntTy);
+  LiteralFields[2] = llvm::Constant::getNullValue(IntTy);
 
   // Function
   LiteralFields[3] = Fn;

clang/lib/CodeGen/CGBuiltin.cpp

@@ -105,7 +105,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     Value *NegOp = Builder.CreateNeg(ArgValue, "neg");
     Value *CmpResult = 
     Builder.CreateICmpSGE(ArgValue, 
-                          VMContext.getNullValue(ArgValue->getType()),
+                          llvm::Constant::getNullValue(ArgValue->getType()),
                                                             "abscond");
     Value *Result = 
       Builder.CreateSelect(CmpResult, ArgValue, NegOp, "abs");
@@ -152,7 +152,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     const llvm::Type *ResultType = ConvertType(E->getType());
     Value *Tmp = Builder.CreateAdd(Builder.CreateCall(F, ArgValue, "tmp"), 
                                    llvm::ConstantInt::get(ArgType, 1), "tmp");
-    Value *Zero = VMContext.getNullValue(ArgType);
+    Value *Zero = llvm::Constant::getNullValue(ArgType);
     Value *IsZero = Builder.CreateICmpEQ(ArgValue, Zero, "iszero");
     Value *Result = Builder.CreateSelect(IsZero, Zero, Tmp, "ffs");
     if (Result->getType() != ResultType)
@@ -508,7 +508,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     Value *Ptr = EmitScalarExpr(E->getArg(0));
     const llvm::Type *ElTy =
       cast<llvm::PointerType>(Ptr->getType())->getElementType();
-    Builder.CreateStore(VMContext.getNullValue(ElTy), Ptr, true);
+    Builder.CreateStore(llvm::Constant::getNullValue(ElTy), Ptr, true);
     return RValue::get(0);
   }
 

clang/lib/CodeGen/CGCXX.cpp

@@ -41,7 +41,7 @@ CodeGenFunction::GenerateStaticCXXBlockVarDeclInit(const VarDecl &D,
   llvm::GlobalValue *GuardV = 
     new llvm::GlobalVariable(CGM.getModule(), llvm::Type::Int64Ty, false,
                              GV->getLinkage(),
-                             VMContext.getNullValue(llvm::Type::Int64Ty),
+                             llvm::Constant::getNullValue(llvm::Type::Int64Ty),
                              GuardVName.c_str());
   
   // Load the first byte of the guard variable.
@@ -50,7 +50,7 @@ CodeGenFunction::GenerateStaticCXXBlockVarDeclInit(const VarDecl &D,
                                       "tmp");
   
   // Compare it against 0.
-  llvm::Value *nullValue = VMContext.getNullValue(llvm::Type::Int8Ty);
+  llvm::Value *nullValue = llvm::Constant::getNullValue(llvm::Type::Int8Ty);
   llvm::Value *ICmp = Builder.CreateICmpEQ(V, nullValue , "tobool");
   
   llvm::BasicBlock *InitBlock = createBasicBlock("init");
@@ -342,7 +342,7 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
     
     llvm::Value *IsNull = 
       Builder.CreateICmpEQ(NewPtr, 
-                           VMContext.getNullValue(NewPtr->getType()),
+                           llvm::Constant::getNullValue(NewPtr->getType()),
                            "isnull");
     
     Builder.CreateCondBr(IsNull, NewNull, NewNotNull);
@@ -383,7 +383,7 @@ llvm::Value *CodeGenFunction::EmitCXXNewExpr(const CXXNewExpr *E) {
     llvm::PHINode *PHI = Builder.CreatePHI(NewPtr->getType());
     PHI->reserveOperandSpace(2);
     PHI->addIncoming(NewPtr, NewNotNull);
-    PHI->addIncoming(VMContext.getNullValue(NewPtr->getType()), NewNull);
+    PHI->addIncoming(llvm::Constant::getNullValue(NewPtr->getType()), NewNull);
     
     NewPtr = PHI;
   }

clang/lib/CodeGen/CGCall.cpp

@@ -513,7 +513,7 @@ void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
     if (FD->hasImplicitReturnZero()) {
       QualType RetTy = FD->getResultType().getUnqualifiedType();
       const llvm::Type* LLVMTy = CGM.getTypes().ConvertType(RetTy);
-      llvm::Constant* Zero = CGM.getLLVMContext().getNullValue(LLVMTy);
+      llvm::Constant* Zero = llvm::Constant::getNullValue(LLVMTy);
       Builder.CreateStore(Zero, ReturnValue);
     }
   }

clang/lib/CodeGen/CGDecl.cpp

@@ -105,7 +105,7 @@ CodeGenFunction::CreateStaticBlockVarDecl(const VarDecl &D,
   const llvm::Type *LTy = CGM.getTypes().ConvertTypeForMem(Ty);
   return new llvm::GlobalVariable(CGM.getModule(), LTy,
                                   Ty.isConstant(getContext()), Linkage,
-                                  VMContext.getNullValue(LTy), Name,
+                                  llvm::Constant::getNullValue(LTy), Name,
                                   0, D.isThreadSpecified(),
                                   Ty.getAddressSpace());
 }

clang/lib/CodeGen/CGExprAgg.cpp

@@ -360,7 +360,7 @@ void AggExprEmitter::EmitInitializationToLValue(Expr* E, LValue LV) {
 void AggExprEmitter::EmitNullInitializationToLValue(LValue LV, QualType T) {
   if (!CGF.hasAggregateLLVMType(T)) {
     // For non-aggregates, we can store zero
-    llvm::Value *Null = CGF.getLLVMContext().getNullValue(CGF.ConvertType(T));
+    llvm::Value *Null = llvm::Constant::getNullValue(CGF.ConvertType(T));
     CGF.EmitStoreThroughLValue(RValue::get(Null), LV, T);
   } else {
     // Otherwise, just memset the whole thing to zero.  This is legal

clang/lib/CodeGen/CGExprComplex.cpp

@@ -182,14 +182,14 @@ public:
     assert(E->getType()->isAnyComplexType() && "Expected complex type!");
     QualType Elem = E->getType()->getAsComplexType()->getElementType();
     llvm::Constant *Null = 
-                       CGF.getLLVMContext().getNullValue(CGF.ConvertType(Elem));
+                       llvm::Constant::getNullValue(CGF.ConvertType(Elem));
     return ComplexPairTy(Null, Null);
   }
   ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) {
     assert(E->getType()->isAnyComplexType() && "Expected complex type!");
     QualType Elem = E->getType()->getAsComplexType()->getElementType();
     llvm::Constant *Null = 
-                       CGF.getLLVMContext().getNullValue(CGF.ConvertType(Elem));
+                       llvm::Constant::getNullValue(CGF.ConvertType(Elem));
     return ComplexPairTy(Null, Null);
   }
   
@@ -315,7 +315,7 @@ ComplexPairTy ComplexExprEmitter::
 VisitImaginaryLiteral(const ImaginaryLiteral *IL) {
   llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr());
   return
-        ComplexPairTy(CGF.getLLVMContext().getNullValue(Imag->getType()), Imag);
+        ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag);
 }
 
 
@@ -362,7 +362,7 @@ ComplexPairTy ComplexExprEmitter::EmitCast(Expr *Op, QualType DestTy) {
   Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy);
   
   // Return (realval, 0).
-  return ComplexPairTy(Elt, CGF.getLLVMContext().getNullValue(Elt->getType()));
+  return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType()));
 }
 
 ComplexPairTy ComplexExprEmitter::VisitPrePostIncDec(const UnaryOperator *E,
@@ -696,7 +696,7 @@ ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) {
   // Empty init list intializes to null
   QualType Ty = E->getType()->getAsComplexType()->getElementType();
   const llvm::Type* LTy = CGF.ConvertType(Ty);
-  llvm::Value* zeroConstant = CGF.getLLVMContext().getNullValue(LTy);
+  llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy);
   return ComplexPairTy(zeroConstant, zeroConstant);
 }
 

clang/lib/CodeGen/CGExprConstant.cpp

@@ -85,7 +85,7 @@ class VISIBILITY_HIDDEN ConstStructBuilder {
           if (NumBytes > 1) 
             Ty = llvm::ArrayType::get(Ty, NumBytes);
           
-          llvm::Constant *Padding = CGM.getLLVMContext().getNullValue(Ty);
+          llvm::Constant *Padding = llvm::Constant::getNullValue(Ty);
           PackedElements.push_back(Padding);
           ElementOffsetInBytes += getSizeInBytes(Padding);
         }
@@ -253,7 +253,7 @@ class VISIBILITY_HIDDEN ConstStructBuilder {
     if (NumBytes > 1) 
       Ty = llvm::ArrayType::get(Ty, NumBytes);
 
-    llvm::Constant *C = CGM.getLLVMContext().getNullValue(Ty);
+    llvm::Constant *C = llvm::Constant::getNullValue(Ty);
     Elements.push_back(C);
     assert(getAlignment(C) == 1 && "Padding must have 1 byte alignment!");
     
@@ -427,7 +427,7 @@ public:
     // Initialize remaining array elements.
     // FIXME: This doesn't handle member pointers correctly!
     for (; i < NumElements; ++i)
-      Elts.push_back(VMContext.getNullValue(ElemTy));
+      Elts.push_back(llvm::Constant::getNullValue(ElemTy));
 
     if (RewriteType) {
       // FIXME: Try to avoid packing the array
@@ -519,7 +519,7 @@ public:
     // FIXME: This doesn't handle member pointers correctly!
     for (unsigned i = 0; i < SType->getNumElements(); ++i) {
       const llvm::Type *FieldTy = SType->getElementType(i);
-      Elts.push_back(VMContext.getNullValue(FieldTy));
+      Elts.push_back(llvm::Constant::getNullValue(FieldTy));
     }
 
     // Copy initializer elements. Skip padding fields.
@@ -574,7 +574,7 @@ public:
       if (NumPadBytes > 1)
         Ty = llvm::ArrayType::get(Ty, NumPadBytes);
 
-      Elts.push_back(VMContext.getNullValue(Ty));
+      Elts.push_back(llvm::Constant::getNullValue(Ty));
       Types.push_back(Ty);
     }
 
@@ -597,14 +597,14 @@ public:
            Field != FieldEnd; ++Field)
         assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
 #endif
-      return VMContext.getNullValue(Ty);
+      return llvm::Constant::getNullValue(Ty);
     }
 
     if (curField->isBitField()) {
       // Create a dummy struct for bit-field insertion
       unsigned NumElts = CGM.getTargetData().getTypeAllocSize(Ty);
       llvm::Constant* NV = 
-        VMContext.getNullValue(llvm::Type::Int8Ty);
+        llvm::Constant::getNullValue(llvm::Type::Int8Ty);
       std::vector<llvm::Constant*> Elts(NumElts, NV);
 
       InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(0));
@@ -644,7 +644,7 @@ public:
     }
 
     for (; i < NumElements; ++i)
-      Elts.push_back(VMContext.getNullValue(ElemTy));
+      Elts.push_back(llvm::Constant::getNullValue(ElemTy));
 
     return llvm::ConstantVector::get(VType, Elts);    
   }
@@ -917,5 +917,5 @@ llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
 llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) {
   // Always return an LLVM null constant for now; this will change when we
   // get support for IRGen of member pointers.
-  return getLLVMContext().getNullValue(getTypes().ConvertType(T));
+  return llvm::Constant::getNullValue(getTypes().ConvertType(T));
 }

clang/lib/CodeGen/CGExprScalar.cpp

@@ -121,10 +121,10 @@ public:
     return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
   }
   Value *VisitCXXZeroInitValueExpr(const CXXZeroInitValueExpr *E) {
-    return VMContext.getNullValue(ConvertType(E->getType()));
+    return llvm::Constant::getNullValue(ConvertType(E->getType()));
   }
   Value *VisitGNUNullExpr(const GNUNullExpr *E) {
-    return VMContext.getNullValue(ConvertType(E->getType()));
+    return llvm::Constant::getNullValue(ConvertType(E->getType()));
   }
   Value *VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) {
     return llvm::ConstantInt::get(ConvertType(E->getType()),
@@ -213,7 +213,7 @@ public:
     // Emit remaining default initializers
     for (/* Do not initialize i*/; i < NumVectorElements; ++i) {
       Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i);
-      llvm::Value *NewV = VMContext.getNullValue(ElementType);
+      llvm::Value *NewV = llvm::Constant::getNullValue(ElementType);
       V = Builder.CreateInsertElement(V, NewV, Idx);
     }
     
@@ -221,7 +221,7 @@ public:
   }
   
   Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) {
-    return VMContext.getNullValue(ConvertType(E->getType()));
+    return llvm::Constant::getNullValue(ConvertType(E->getType()));
   }
   Value *VisitImplicitCastExpr(const ImplicitCastExpr *E);
   Value *VisitCastExpr(const CastExpr *E) {
@@ -387,7 +387,7 @@ Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
   
   if (SrcType->isRealFloatingType()) {
     // Compare against 0.0 for fp scalars.
-    llvm::Value *Zero = VMContext.getNullValue(Src->getType());
+    llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType());
     return Builder.CreateFCmpUNE(Src, Zero, "tobool");
   }
   
@@ -410,7 +410,7 @@ Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
   }
   
   // Compare against an integer or pointer null.
-  llvm::Value *Zero = VMContext.getNullValue(Src->getType());
+  llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType());
   return Builder.CreateICmpNE(Src, Zero, "tobool");
 }
 
@@ -838,7 +838,7 @@ Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) {
     CGF.EmitLValue(Op);
   else
     CGF.EmitScalarExpr(Op, true);
-  return VMContext.getNullValue(ConvertType(E->getType()));
+  return llvm::Constant::getNullValue(ConvertType(E->getType()));
 }
 
 Value *ScalarExprEmitter::VisitUnaryOffsetOf(const UnaryOperator *E)
@@ -1311,7 +1311,7 @@ Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
     
     // 0 && RHS: If it is safe, just elide the RHS, and return 0.
     if (!CGF.ContainsLabel(E->getRHS()))
-      return VMContext.getNullValue(CGF.LLVMIntTy);
+      return llvm::Constant::getNullValue(CGF.LLVMIntTy);
   }
   
   llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end");

clang/lib/CodeGen/CGObjC.cpp

@@ -481,7 +481,7 @@ void CodeGenFunction::EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S){
   llvm::BasicBlock *SetStartMutations = createBasicBlock("setstartmutations");
   
   llvm::Value *Limit = Builder.CreateLoad(LimitPtr);
-  llvm::Value *Zero = VMContext.getNullValue(UnsignedLongLTy);
+  llvm::Value *Zero = llvm::Constant::getNullValue(UnsignedLongLTy);
 
   llvm::Value *IsZero = Builder.CreateICmpEQ(Limit, Zero, "iszero");
   Builder.CreateCondBr(IsZero, NoElements, SetStartMutations);
@@ -611,7 +611,7 @@ void CodeGenFunction::EmitObjCForCollectionStmt(const ObjCForCollectionStmt &S){
     LValue LV = EmitLValue(cast<Expr>(S.getElement()));
     
     // Set the value to null.
-    Builder.CreateStore(VMContext.getNullValue(ConvertType(ElementTy)),
+    Builder.CreateStore(llvm::Constant::getNullValue(ConvertType(ElementTy)),
                         LV.getAddress());
   }
 

clang/lib/CodeGen/CGObjCGNU.cpp

@@ -1049,7 +1049,7 @@ llvm::Function *CGObjCGNU::ModuleInitFunction() {
       llvm::ArrayType::get(StaticsListPtrTy, 2);
     Elements.clear();
     Elements.push_back(Statics);
-    Elements.push_back(VMContext.getNullValue(StaticsListPtrTy));
+    Elements.push_back(llvm::Constant::getNullValue(StaticsListPtrTy));
     Statics = MakeGlobal(StaticsListArrayTy, Elements, ".objc_statics_ptr");
     Statics = llvm::ConstantExpr::getBitCast(Statics, PtrTy);
   }

clang/lib/CodeGen/CGObjCMac.cpp

@@ -1726,7 +1726,7 @@ CGObjCMac::EmitProtocolExtension(const ObjCProtocolDecl *PD,
   // Return null if no extension bits are used.
   if (Values[1]->isNullValue() && Values[2]->isNullValue() && 
       Values[3]->isNullValue())
-    return VMContext.getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
 
   llvm::Constant *Init = 
     llvm::ConstantStruct::get(ObjCTypes.ProtocolExtensionTy, Values);
@@ -1755,14 +1755,14 @@ CGObjCMac::EmitProtocolList(const std::string &Name,
 
   // Just return null for empty protocol lists
   if (ProtocolRefs.empty()) 
-    return VMContext.getNullValue(ObjCTypes.ProtocolListPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
 
   // This list is null terminated.
-  ProtocolRefs.push_back(VMContext.getNullValue(ObjCTypes.ProtocolPtrTy));
+  ProtocolRefs.push_back(llvm::Constant::getNullValue(ObjCTypes.ProtocolPtrTy));
 
   std::vector<llvm::Constant*> Values(3);
   // This field is only used by the runtime.
-  Values[0] = VMContext.getNullValue(ObjCTypes.ProtocolListPtrTy);
+  Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
   Values[1] = llvm::ConstantInt::get(ObjCTypes.LongTy,
                                        ProtocolRefs.size() - 1);
   Values[2] = 
@@ -1805,7 +1805,7 @@ llvm::Constant *CGObjCCommonMac::EmitPropertyList(const std::string &Name,
 
   // Return null for empty list.
   if (Properties.empty())
-    return VMContext.getNullValue(ObjCTypes.PropertyListPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
 
   unsigned PropertySize = 
     CGM.getTargetData().getTypeAllocSize(ObjCTypes.PropertyTy);
@@ -1848,7 +1848,7 @@ llvm::Constant *CGObjCMac::EmitMethodDescList(const std::string &Name,
                                               const ConstantVector &Methods) {
   // Return null for empty list.
   if (Methods.empty())
-    return VMContext.getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
 
   std::vector<llvm::Constant*> Values(2);
   Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
@@ -1917,7 +1917,7 @@ void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
                        Category->protocol_begin(),
                        Category->protocol_end());
   } else {
-    Values[4] = VMContext.getNullValue(ObjCTypes.ProtocolListPtrTy);
+    Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
   }
   Values[5] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
 
@@ -1926,7 +1926,7 @@ void CGObjCMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
     Values[6] = EmitPropertyList(std::string("\01l_OBJC_$_PROP_LIST_") + ExtName,
                                  OCD, Category, ObjCTypes);
   } else {
-    Values[6] = VMContext.getNullValue(ObjCTypes.PropertyListPtrTy);
+    Values[6] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
   }
   
   llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.CategoryTy,
@@ -2026,7 +2026,7 @@ void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
       llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
                                      ObjCTypes.ClassPtrTy);
   } else {
-    Values[ 1] = VMContext.getNullValue(ObjCTypes.ClassPtrTy);
+    Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
   }
   Values[ 2] = GetClassName(ID->getIdentifier());
   // Version is always 0.
@@ -2039,7 +2039,7 @@ void CGObjCMac::GenerateClass(const ObjCImplementationDecl *ID) {
                    "__OBJC,__inst_meth,regular,no_dead_strip",
                    InstanceMethods);
   // cache is always NULL.
-  Values[ 8] = VMContext.getNullValue(ObjCTypes.CachePtrTy);
+  Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
   Values[ 9] = Protocols;
   Values[10] = BuildIvarLayout(ID, true); 
   Values[11] = EmitClassExtension(ID);
@@ -2078,7 +2078,7 @@ llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
       llvm::ConstantExpr::getBitCast(GetClassName(Super->getIdentifier()),
                                      ObjCTypes.ClassPtrTy);
   } else {
-    Values[ 1] = VMContext.getNullValue(ObjCTypes.ClassPtrTy);
+    Values[ 1] = llvm::Constant::getNullValue(ObjCTypes.ClassPtrTy);
   }
   Values[ 2] = GetClassName(ID->getIdentifier());
   // Version is always 0.
@@ -2091,12 +2091,12 @@ llvm::Constant *CGObjCMac::EmitMetaClass(const ObjCImplementationDecl *ID,
                    "__OBJC,__cls_meth,regular,no_dead_strip",
                    Methods);
   // cache is always NULL.
-  Values[ 8] = VMContext.getNullValue(ObjCTypes.CachePtrTy);
+  Values[ 8] = llvm::Constant::getNullValue(ObjCTypes.CachePtrTy);
   Values[ 9] = Protocols;
   // ivar_layout for metaclass is always NULL.
-  Values[10] = VMContext.getNullValue(ObjCTypes.Int8PtrTy);
+  Values[10] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
   // The class extension is always unused for metaclasses.
-  Values[11] = VMContext.getNullValue(ObjCTypes.ClassExtensionPtrTy);
+  Values[11] = llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
   llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ClassTy,
                                                    Values);
 
@@ -2167,7 +2167,7 @@ CGObjCMac::EmitClassExtension(const ObjCImplementationDecl *ID) {
 
   // Return null if no extension bits are used.
   if (Values[1]->isNullValue() && Values[2]->isNullValue())
-    return VMContext.getNullValue(ObjCTypes.ClassExtensionPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.ClassExtensionPtrTy);
 
   llvm::Constant *Init = 
     llvm::ConstantStruct::get(ObjCTypes.ClassExtensionTy, Values);
@@ -2198,7 +2198,7 @@ llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
   // the cleanest solution would be to make up an ObjCInterfaceDecl
   // for the class.
   if (ForClass)
-    return VMContext.getNullValue(ObjCTypes.IvarListPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
   
   ObjCInterfaceDecl *OID = 
     const_cast<ObjCInterfaceDecl*>(ID->getClassInterface());
@@ -2220,7 +2220,7 @@ llvm::Constant *CGObjCMac::EmitIvarList(const ObjCImplementationDecl *ID,
 
   // Return null for empty list.
   if (Ivars.empty())
-    return VMContext.getNullValue(ObjCTypes.IvarListPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.IvarListPtrTy);
 
   std::vector<llvm::Constant*> Values(2);
   Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Ivars.size());
@@ -2279,10 +2279,10 @@ llvm::Constant *CGObjCMac::EmitMethodList(const std::string &Name,
                                           const ConstantVector &Methods) {
   // Return null for empty list.
   if (Methods.empty())
-    return VMContext.getNullValue(ObjCTypes.MethodListPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.MethodListPtrTy);
 
   std::vector<llvm::Constant*> Values(3);
-  Values[0] = VMContext.getNullValue(ObjCTypes.Int8PtrTy);
+  Values[0] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
   Values[1] = llvm::ConstantInt::get(ObjCTypes.IntTy, Methods.size());
   llvm::ArrayType *AT = llvm::ArrayType::get(ObjCTypes.MethodTy,
                                              Methods.size());
@@ -2894,11 +2894,11 @@ llvm::Constant *CGObjCMac::EmitModuleSymbols() {
 
   // Return null if no symbols were defined.
   if (!NumClasses && !NumCategories)
-    return VMContext.getNullValue(ObjCTypes.SymtabPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.SymtabPtrTy);
 
   std::vector<llvm::Constant*> Values(5);
   Values[0] = llvm::ConstantInt::get(ObjCTypes.LongTy, 0);
-  Values[1] = VMContext.getNullValue(ObjCTypes.SelectorPtrTy);
+  Values[1] = llvm::Constant::getNullValue(ObjCTypes.SelectorPtrTy);
   Values[2] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumClasses);
   Values[3] = llvm::ConstantInt::get(ObjCTypes.ShortTy, NumCategories);
 
@@ -2978,7 +2978,7 @@ llvm::Constant *CGObjCCommonMac::GetClassName(IdentifierInfo *Ident) {
 /// ivar layout bitmap.
 llvm::Constant *CGObjCCommonMac::GetIvarLayoutName(IdentifierInfo *Ident,
                                       const ObjCCommonTypesHelper &ObjCTypes) {
-  return VMContext.getNullValue(ObjCTypes.Int8PtrTy);
+  return llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
 }
 
 static QualType::GCAttrTypes GetGCAttrTypeForType(ASTContext &Ctx, 
@@ -3187,7 +3187,7 @@ llvm::Constant *CGObjCCommonMac::BuildIvarLayout(
   unsigned int WordsToScan, WordsToSkip;
   const llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
   if (CGM.getLangOptions().getGCMode() == LangOptions::NonGC)
-    return VMContext.getNullValue(PtrTy);
+    return llvm::Constant::getNullValue(PtrTy);
   
   llvm::SmallVector<FieldDecl*, 32> RecFields;
   const ObjCInterfaceDecl *OI = OMD->getClassInterface();
@@ -3200,14 +3200,14 @@ llvm::Constant *CGObjCCommonMac::BuildIvarLayout(
     RecFields.push_back(cast<FieldDecl>(Ivars[k]));
   
   if (RecFields.empty())
-    return VMContext.getNullValue(PtrTy);
+    return llvm::Constant::getNullValue(PtrTy);
   
   SkipIvars.clear(); 
   IvarsInfo.clear();
   
   BuildAggrIvarLayout(OMD, 0, 0, RecFields, 0, ForStrongLayout, hasUnion);
   if (IvarsInfo.empty())
-    return VMContext.getNullValue(PtrTy);
+    return llvm::Constant::getNullValue(PtrTy);
   
   // Sort on byte position in case we encounterred a union nested in
   // the ivar list.
@@ -3348,7 +3348,7 @@ llvm::Constant *CGObjCCommonMac::BuildIvarLayout(
   // if ivar_layout bitmap is all 1 bits (nothing skipped) then use NULL as
   // final layout.
   if (ForStrongLayout && !BytesSkipped)
-    return VMContext.getNullValue(PtrTy);
+    return llvm::Constant::getNullValue(PtrTy);
   llvm::GlobalVariable * Entry = CreateMetadataVar("\01L_OBJC_CLASS_NAME_",
                                     llvm::ConstantArray::get(BitMap.c_str()),
                                       "__TEXT,__cstring,cstring_literals",
@@ -3463,11 +3463,11 @@ void CGObjCMac::FinishModule() {
       continue;
 
     std::vector<llvm::Constant*> Values(5);
-    Values[0] = VMContext.getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
+    Values[0] = llvm::Constant::getNullValue(ObjCTypes.ProtocolExtensionPtrTy);
     Values[1] = GetClassName(I->first);
-    Values[2] = VMContext.getNullValue(ObjCTypes.ProtocolListPtrTy);
+    Values[2] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListPtrTy);
     Values[3] = Values[4] =
-      VMContext.getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
+      llvm::Constant::getNullValue(ObjCTypes.MethodDescriptionListPtrTy);
     I->second->setLinkage(llvm::GlobalValue::InternalLinkage);
     I->second->setInitializer(llvm::ConstantStruct::get(ObjCTypes.ProtocolTy,
                                                         Values));
@@ -4242,13 +4242,13 @@ llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassRoTInitializer(
                                 OID->protocol_end());
   
   if (flags & CLS_META)
-    Values[ 7] = VMContext.getNullValue(ObjCTypes.IvarListnfABIPtrTy);
+    Values[ 7] = llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
   else
     Values[ 7] = EmitIvarList(ID);
   Values[ 8] = (flags & CLS_META) ? GetIvarLayoutName(0, ObjCTypes) 
                                   : BuildIvarLayout(ID, false); 
   if (flags & CLS_META)
-    Values[ 9] = VMContext.getNullValue(ObjCTypes.PropertyListPtrTy);
+    Values[ 9] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
   else
     Values[ 9] = 
       EmitPropertyList("\01l_OBJC_$_PROP_LIST_" + ID->getNameAsString(),
@@ -4289,7 +4289,7 @@ llvm::GlobalVariable * CGObjCNonFragileABIMac::BuildClassMetaData(
   Values[0] = IsAGV;
   Values[1] = SuperClassGV 
                 ? SuperClassGV
-                : VMContext.getNullValue(ObjCTypes.ClassnfABIPtrTy);
+                : llvm::Constant::getNullValue(ObjCTypes.ClassnfABIPtrTy);
   Values[2] = ObjCEmptyCacheVar;  // &ObjCEmptyCacheVar
   Values[3] = ObjCEmptyVtableVar; // &ObjCEmptyVtableVar
   Values[4] = ClassRoGV;                 // &CLASS_RO_GV
@@ -4524,8 +4524,8 @@ void CGObjCNonFragileABIMac::GenerateCategory(const ObjCCategoryImplDecl *OCD) {
       EmitPropertyList(std::string("\01l_OBJC_$_PROP_LIST_") + ExtName,
                        OCD, Category, ObjCTypes);
   } else {
-    Values[4] = VMContext.getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
+    Values[4] = llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
-    Values[5] = VMContext.getNullValue(ObjCTypes.PropertyListPtrTy);
+    Values[5] = llvm::Constant::getNullValue(ObjCTypes.PropertyListPtrTy);
   }
     
   llvm::Constant *Init = 
@@ -4580,7 +4580,7 @@ llvm::Constant *CGObjCNonFragileABIMac::EmitMethodList(
                                               const ConstantVector &Methods) {
   // Return null for empty list.
   if (Methods.empty())
-    return VMContext.getNullValue(ObjCTypes.MethodListnfABIPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.MethodListnfABIPtrTy);
   
   std::vector<llvm::Constant*> Values(3);
   // sizeof(struct _objc_method)
@@ -4709,7 +4709,7 @@ llvm::Constant *CGObjCNonFragileABIMac::EmitIvarList(
   }
   // Return null for empty list.
   if (Ivars.empty())
-    return VMContext.getNullValue(ObjCTypes.IvarListnfABIPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.IvarListnfABIPtrTy);
   std::vector<llvm::Constant*> Values(3);
   unsigned Size = CGM.getTargetData().getTypeAllocSize(ObjCTypes.IvarnfABITy);
   Values[0] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
@@ -4805,7 +4805,7 @@ llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
   
   std::vector<llvm::Constant*> Values(10);
   // isa is NULL
-  Values[0] = VMContext.getNullValue(ObjCTypes.ObjectPtrTy);
+  Values[0] = llvm::Constant::getNullValue(ObjCTypes.ObjectPtrTy);
   Values[1] = GetClassName(PD->getIdentifier());
   Values[2] = EmitProtocolList(
                           "\01l_OBJC_$_PROTOCOL_REFS_" + PD->getNameAsString(),
@@ -4833,7 +4833,7 @@ llvm::Constant *CGObjCNonFragileABIMac::GetOrEmitProtocol(
   uint32_t Size = 
     CGM.getTargetData().getTypeAllocSize(ObjCTypes.ProtocolnfABITy);
   Values[8] = llvm::ConstantInt::get(ObjCTypes.IntTy, Size);
-  Values[9] = VMContext.getNullValue(ObjCTypes.IntTy);
+  Values[9] = llvm::Constant::getNullValue(ObjCTypes.IntTy);
   llvm::Constant *Init = llvm::ConstantStruct::get(ObjCTypes.ProtocolnfABITy,
                                                    Values);
   
@@ -4887,7 +4887,7 @@ CGObjCNonFragileABIMac::EmitProtocolList(const std::string &Name,
   
   // Just return null for empty protocol lists
   if (begin == end) 
-    return VMContext.getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
+    return llvm::Constant::getNullValue(ObjCTypes.ProtocolListnfABIPtrTy);
   
   // FIXME: We shouldn't need to do this lookup here, should we?
   llvm::GlobalVariable *GV = CGM.getModule().getGlobalVariable(Name, true);
@@ -4899,7 +4899,7 @@ CGObjCNonFragileABIMac::EmitProtocolList(const std::string &Name,
     ProtocolRefs.push_back(GetProtocolRef(*begin));  // Implemented???
 
   // This list is null terminated.
-  ProtocolRefs.push_back(VMContext.getNullValue(
+  ProtocolRefs.push_back(llvm::Constant::getNullValue(
                                             ObjCTypes.ProtocolnfABIPtrTy));
   
   std::vector<llvm::Constant*> Values(2);
@@ -4939,7 +4939,7 @@ CGObjCNonFragileABIMac::GetMethodDescriptionConstant(const ObjCMethodDecl *MD) {
                                            ObjCTypes.SelectorPtrTy);
   Desc[1] = GetMethodVarType(MD);
   // Protocol methods have no implementation. So, this entry is always NULL.
-  Desc[2] = VMContext.getNullValue(ObjCTypes.Int8PtrTy);
+  Desc[2] = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
   return llvm::ConstantStruct::get(ObjCTypes.MethodTy, Desc);
 }
 
@@ -5430,7 +5430,7 @@ CGObjCNonFragileABIMac::EmitTryOrSynchronizedStmt(CodeGen::CodeGenFunction &CGF,
         // catch(...) always matches.
         if (!CatchDecl) {
           // Use i8* null here to signal this is a catch all, not a cleanup.
-          llvm::Value *Null = VMContext.getNullValue(ObjCTypes.Int8PtrTy);
+          llvm::Value *Null = llvm::Constant::getNullValue(ObjCTypes.Int8PtrTy);
           SelectorArgs.push_back(Null);
           HasCatchAll = true;
           break;

clang/lib/CodeGen/CodeGenFunction.cpp

@@ -430,7 +430,7 @@ void CodeGenFunction::EmitMemSetToZero(llvm::Value *DestPtr, QualType Ty) {
   const llvm::Type *IntPtr = llvm::IntegerType::get(LLVMPointerWidth);
 
   Builder.CreateCall4(CGM.getMemSetFn(), DestPtr,
-                      getLLVMContext().getNullValue(llvm::Type::Int8Ty),
+                      llvm::Constant::getNullValue(llvm::Type::Int8Ty),
                       // TypeInfo.first describes size in bits.
                       llvm::ConstantInt::get(IntPtr, TypeInfo.first/8),
                       llvm::ConstantInt::get(llvm::Type::Int32Ty, 
@@ -595,7 +595,7 @@ CodeGenFunction::CleanupBlockInfo CodeGenFunction::PopCleanupBlock()
       
       // If we had a current basic block, we also need to emit an instruction
       // to initialize the cleanup destination.
-      Builder.CreateStore(getLLVMContext().getNullValue(llvm::Type::Int32Ty),
+      Builder.CreateStore(llvm::Constant::getNullValue(llvm::Type::Int32Ty),
                           DestCodePtr);
     } else
       Builder.ClearInsertionPoint();

clang/lib/CodeGen/CodeGenModule.cpp

@@ -810,7 +810,7 @@ void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) {
     // exists. A use may still exists, however, so we still may need
     // to do a RAUW.
     assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type");
-    Init = getLLVMContext().getNullValue(getTypes().ConvertTypeForMem(ASTTy));
+    Init = llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(ASTTy));
   } else {
     Init = EmitConstantExpr(D->getInit(), D->getType());
     if (!Init) {
@@ -1192,7 +1192,7 @@ static void appendFieldAndPadding(CodeGenModule &CGM,
   // Append padding
   for (int i = StructFieldNo + 1; i < NextStructFieldNo; i++) {
     llvm::Constant *C = 
-      CGM.getLLVMContext().getNullValue(STy->getElementType(StructFieldNo + 1));
+      llvm::Constant::getNullValue(STy->getElementType(StructFieldNo + 1));
     
     Fields.push_back(C);
   }
@@ -1268,7 +1268,7 @@ CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) {
   if (llvm::Constant *C = Entry.getValue())
     return C;
   
-  llvm::Constant *Zero = getLLVMContext().getNullValue(llvm::Type::Int32Ty);
+  llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
   llvm::Constant *Zeros[] = { Zero, Zero };
   
   // If we don't already have it, get __CFConstantStringClassReference.