Update clang to r84119.

1 files changed, 135 insertions, 120 deletions

diff --git a/lib/CodeGen/CGBuiltin.cpp b/lib/CodeGen/CGBuiltin.cpp
index a919dfa..987cd24 100644
--- a/lib/CodeGen/CGBuiltin.cpp
+++ b/lib/CodeGen/CGBuiltin.cpp
@@ -25,21 +25,21 @@ using namespace llvm;
 
 /// Utility to insert an atomic instruction based on Instrinsic::ID
 /// and the expression node.
-static RValue EmitBinaryAtomic(CodeGenFunction& CGF, 
+static RValue EmitBinaryAtomic(CodeGenFunction& CGF,
                                Intrinsic::ID Id, const CallExpr *E) {
   const llvm::Type *ResType[2];
   ResType[0] = CGF.ConvertType(E->getType());
   ResType[1] = CGF.ConvertType(E->getArg(0)->getType());
   Value *AtomF = CGF.CGM.getIntrinsic(Id, ResType, 2);
-  return RValue::get(CGF.Builder.CreateCall2(AtomF, 
-                                             CGF.EmitScalarExpr(E->getArg(0)), 
+  return RValue::get(CGF.Builder.CreateCall2(AtomF,
+                                             CGF.EmitScalarExpr(E->getArg(0)),
                                              CGF.EmitScalarExpr(E->getArg(1))));
 }
 
 /// Utility to insert an atomic instruction based Instrinsic::ID and
 // the expression node, where the return value is the result of the
 // operation.
-static RValue EmitBinaryAtomicPost(CodeGenFunction& CGF, 
+static RValue EmitBinaryAtomicPost(CodeGenFunction& CGF,
                                    Intrinsic::ID Id, const CallExpr *E,
                                    Instruction::BinaryOps Op) {
   const llvm::Type *ResType[2];
@@ -49,25 +49,26 @@ static RValue EmitBinaryAtomicPost(CodeGenFunction& CGF,
   Value *Ptr = CGF.EmitScalarExpr(E->getArg(0));
   Value *Operand = CGF.EmitScalarExpr(E->getArg(1));
   Value *Result = CGF.Builder.CreateCall2(AtomF, Ptr, Operand);
-  
+
   if (Id == Intrinsic::atomic_load_nand)
     Result = CGF.Builder.CreateNot(Result);
-  
-  
+
+
   return RValue::get(CGF.Builder.CreateBinOp(Op, Result, Operand));
 }
 
-RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD, 
+RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
                                         unsigned BuiltinID, const CallExpr *E) {
   // See if we can constant fold this builtin.  If so, don't emit it at all.
   Expr::EvalResult Result;
   if (E->Evaluate(Result, CGM.getContext())) {
     if (Result.Val.isInt())
-      return RValue::get(llvm::ConstantInt::get(Result.Val.getInt()));
+      return RValue::get(llvm::ConstantInt::get(VMContext,
+                                                Result.Val.getInt()));
     else if (Result.Val.isFloat())
-      return RValue::get(llvm::ConstantFP::get(Result.Val.getFloat()));
+      return RValue::get(ConstantFP::get(VMContext, Result.Val.getFloat()));
   }
-      
+
   switch (BuiltinID) {
   default: break;  // Handle intrinsics and libm functions below.
   case Builtin::BI__builtin___CFStringMakeConstantString:
@@ -76,13 +77,12 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
   case Builtin::BI__builtin_va_start:
   case Builtin::BI__builtin_va_end: {
     Value *ArgValue = EmitVAListRef(E->getArg(0));
-    const llvm::Type *DestType = 
-      llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
+    const llvm::Type *DestType = llvm::Type::getInt8PtrTy(VMContext);
     if (ArgValue->getType() != DestType)
-      ArgValue = Builder.CreateBitCast(ArgValue, DestType, 
-                                       ArgValue->getNameStart());
+      ArgValue = Builder.CreateBitCast(ArgValue, DestType,
+                                       ArgValue->getName().data());
 
-    Intrinsic::ID inst = (BuiltinID == Builtin::BI__builtin_va_end) ? 
+    Intrinsic::ID inst = (BuiltinID == Builtin::BI__builtin_va_end) ?
       Intrinsic::vaend : Intrinsic::vastart;
     return RValue::get(Builder.CreateCall(CGM.getIntrinsic(inst), ArgValue));
   }
@@ -90,35 +90,35 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     Value *DstPtr = EmitVAListRef(E->getArg(0));
     Value *SrcPtr = EmitVAListRef(E->getArg(1));
 
-    const llvm::Type *Type = 
-      llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
+    const llvm::Type *Type = llvm::Type::getInt8PtrTy(VMContext);
 
     DstPtr = Builder.CreateBitCast(DstPtr, Type);
     SrcPtr = Builder.CreateBitCast(SrcPtr, Type);
-    return RValue::get(Builder.CreateCall2(CGM.getIntrinsic(Intrinsic::vacopy), 
+    return RValue::get(Builder.CreateCall2(CGM.getIntrinsic(Intrinsic::vacopy),
                                            DstPtr, SrcPtr));
   }
   case Builtin::BI__builtin_abs: {
-    Value *ArgValue = EmitScalarExpr(E->getArg(0));   
-    
+    Value *ArgValue = EmitScalarExpr(E->getArg(0));
+
     Value *NegOp = Builder.CreateNeg(ArgValue, "neg");
-    Value *CmpResult = 
-    Builder.CreateICmpSGE(ArgValue, Constant::getNullValue(ArgValue->getType()),
+    Value *CmpResult =
+    Builder.CreateICmpSGE(ArgValue,
+                          llvm::Constant::getNullValue(ArgValue->getType()),
                                                             "abscond");
-    Value *Result = 
+    Value *Result =
       Builder.CreateSelect(CmpResult, ArgValue, NegOp, "abs");
-    
+
     return RValue::get(Result);
   }
   case Builtin::BI__builtin_ctz:
   case Builtin::BI__builtin_ctzl:
   case Builtin::BI__builtin_ctzll: {
     Value *ArgValue = EmitScalarExpr(E->getArg(0));
-    
+
     const llvm::Type *ArgType = ArgValue->getType();
     Value *F = CGM.getIntrinsic(Intrinsic::cttz, &ArgType, 1);
 
-    const llvm::Type *ResultType = ConvertType(E->getType());    
+    const llvm::Type *ResultType = ConvertType(E->getType());
     Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
     if (Result->getType() != ResultType)
       Result = Builder.CreateIntCast(Result, ResultType, "cast");
@@ -128,11 +128,11 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
   case Builtin::BI__builtin_clzl:
   case Builtin::BI__builtin_clzll: {
     Value *ArgValue = EmitScalarExpr(E->getArg(0));
-    
+
     const llvm::Type *ArgType = ArgValue->getType();
     Value *F = CGM.getIntrinsic(Intrinsic::ctlz, &ArgType, 1);
 
-    const llvm::Type *ResultType = ConvertType(E->getType());    
+    const llvm::Type *ResultType = ConvertType(E->getType());
     Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
     if (Result->getType() != ResultType)
       Result = Builder.CreateIntCast(Result, ResultType, "cast");
@@ -143,13 +143,13 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
   case Builtin::BI__builtin_ffsll: {
     // ffs(x) -> x ? cttz(x) + 1 : 0
     Value *ArgValue = EmitScalarExpr(E->getArg(0));
-    
+
     const llvm::Type *ArgType = ArgValue->getType();
     Value *F = CGM.getIntrinsic(Intrinsic::cttz, &ArgType, 1);
-        
+
     const llvm::Type *ResultType = ConvertType(E->getType());
-    Value *Tmp = Builder.CreateAdd(Builder.CreateCall(F, ArgValue, "tmp"), 
-                                   ConstantInt::get(ArgType, 1), "tmp");
+    Value *Tmp = Builder.CreateAdd(Builder.CreateCall(F, ArgValue, "tmp"),
+                                   llvm::ConstantInt::get(ArgType, 1), "tmp");
     Value *Zero = llvm::Constant::getNullValue(ArgType);
     Value *IsZero = Builder.CreateICmpEQ(ArgValue, Zero, "iszero");
     Value *Result = Builder.CreateSelect(IsZero, Zero, Tmp, "ffs");
@@ -162,13 +162,13 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
   case Builtin::BI__builtin_parityll: {
     // parity(x) -> ctpop(x) & 1
     Value *ArgValue = EmitScalarExpr(E->getArg(0));
-    
+
     const llvm::Type *ArgType = ArgValue->getType();
     Value *F = CGM.getIntrinsic(Intrinsic::ctpop, &ArgType, 1);
-    
+
     const llvm::Type *ResultType = ConvertType(E->getType());
     Value *Tmp = Builder.CreateCall(F, ArgValue, "tmp");
-    Value *Result = Builder.CreateAnd(Tmp, ConstantInt::get(ArgType, 1), 
+    Value *Result = Builder.CreateAnd(Tmp, llvm::ConstantInt::get(ArgType, 1),
                                       "tmp");
     if (Result->getType() != ResultType)
       Result = Builder.CreateIntCast(Result, ResultType, "cast");
@@ -178,10 +178,10 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
   case Builtin::BI__builtin_popcountl:
   case Builtin::BI__builtin_popcountll: {
     Value *ArgValue = EmitScalarExpr(E->getArg(0));
-    
+
     const llvm::Type *ArgType = ArgValue->getType();
     Value *F = CGM.getIntrinsic(Intrinsic::ctpop, &ArgType, 1);
-    
+
     const llvm::Type *ResultType = ConvertType(E->getType());
     Value *Result = Builder.CreateCall(F, ArgValue, "tmp");
     if (Result->getType() != ResultType)
@@ -197,7 +197,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     const llvm::Type *ArgType = ArgValue->getType();
     Value *F = CGM.getIntrinsic(Intrinsic::bswap, &ArgType, 1);
     return RValue::get(Builder.CreateCall(F, ArgValue, "tmp"));
-  }    
+  }
   case Builtin::BI__builtin_object_size: {
     // FIXME: Implement. For now we just always fail and pretend we
     // don't know the object size.
@@ -205,15 +205,16 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     const llvm::Type *ResType = ConvertType(E->getType());
     //    bool UseSubObject = TypeArg.getZExtValue() & 1;
     bool UseMinimum = TypeArg.getZExtValue() & 2;
-    return RValue::get(ConstantInt::get(ResType, UseMinimum ? 0 : -1LL));
+    return RValue::get(
+      llvm::ConstantInt::get(ResType, UseMinimum ? 0 : -1LL));
   }
   case Builtin::BI__builtin_prefetch: {
     Value *Locality, *RW, *Address = EmitScalarExpr(E->getArg(0));
     // FIXME: Technically these constants should of type 'int', yes?
-    RW = (E->getNumArgs() > 1) ? EmitScalarExpr(E->getArg(1)) : 
-      ConstantInt::get(llvm::Type::Int32Ty, 0);
-    Locality = (E->getNumArgs() > 2) ? EmitScalarExpr(E->getArg(2)) : 
-      ConstantInt::get(llvm::Type::Int32Ty, 3);
+    RW = (E->getNumArgs() > 1) ? EmitScalarExpr(E->getArg(1)) :
+      llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 0);
+    Locality = (E->getNumArgs() > 2) ? EmitScalarExpr(E->getArg(2)) :
+      llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 3);
     Value *F = CGM.getIntrinsic(Intrinsic::prefetch, 0, 0);
     return RValue::get(Builder.CreateCall3(F, Address, RW, Locality));
   }
@@ -221,7 +222,12 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     Value *F = CGM.getIntrinsic(Intrinsic::trap, 0, 0);
     return RValue::get(Builder.CreateCall(F));
   }
-
+  case Builtin::BI__builtin_unreachable: {
+    Value *V = Builder.CreateUnreachable();
+    Builder.ClearInsertionPoint();
+    return RValue::get(V);
+  }
+      
   case Builtin::BI__builtin_powi:
   case Builtin::BI__builtin_powif:
   case Builtin::BI__builtin_powil: {
@@ -240,9 +246,9 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
   case Builtin::BI__builtin_isunordered: {
     // Ordered comparisons: we know the arguments to these are matching scalar
     // floating point values.
-    Value *LHS = EmitScalarExpr(E->getArg(0));   
+    Value *LHS = EmitScalarExpr(E->getArg(0));
     Value *RHS = EmitScalarExpr(E->getArg(1));
-    
+
     switch (BuiltinID) {
     default: assert(0 && "Unknown ordered comparison");
     case Builtin::BI__builtin_isgreater:
@@ -260,7 +266,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     case Builtin::BI__builtin_islessgreater:
       LHS = Builder.CreateFCmpONE(LHS, RHS, "cmp");
       break;
-    case Builtin::BI__builtin_isunordered:    
+    case Builtin::BI__builtin_isunordered:
       LHS = Builder.CreateFCmpUNO(LHS, RHS, "cmp");
       break;
     }
@@ -268,19 +274,24 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     return RValue::get(Builder.CreateZExt(LHS, ConvertType(E->getType()),
                                           "tmp"));
   }
+  case Builtin::BI__builtin_isnan: {
+    Value *V = EmitScalarExpr(E->getArg(0));
+    V = Builder.CreateFCmpUNO(V, V, "cmp");
+    return RValue::get(Builder.CreateZExt(V, ConvertType(E->getType()), "tmp"));
+  }
   case Builtin::BIalloca:
   case Builtin::BI__builtin_alloca: {
     // FIXME: LLVM IR Should allow alloca with an i64 size!
     Value *Size = EmitScalarExpr(E->getArg(0));
-    Size = Builder.CreateIntCast(Size, llvm::Type::Int32Ty, false, "tmp");
-    return RValue::get(Builder.CreateAlloca(llvm::Type::Int8Ty, Size, "tmp"));
+    Size = Builder.CreateIntCast(Size, llvm::Type::getInt32Ty(VMContext), false, "tmp");
+    return RValue::get(Builder.CreateAlloca(llvm::Type::getInt8Ty(VMContext), Size, "tmp"));
   }
   case Builtin::BI__builtin_bzero: {
     Value *Address = EmitScalarExpr(E->getArg(0));
     Builder.CreateCall4(CGM.getMemSetFn(), Address,
-                        llvm::ConstantInt::get(llvm::Type::Int8Ty, 0),
+                        llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), 0),
                         EmitScalarExpr(E->getArg(1)),
-                        llvm::ConstantInt::get(llvm::Type::Int32Ty, 1));
+                        llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1));
     return RValue::get(Address);
   }
   case Builtin::BI__builtin_memcpy: {
@@ -288,7 +299,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     Builder.CreateCall4(CGM.getMemCpyFn(), Address,
                         EmitScalarExpr(E->getArg(1)),
                         EmitScalarExpr(E->getArg(2)),
-                        llvm::ConstantInt::get(llvm::Type::Int32Ty, 1));
+                        llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1));
     return RValue::get(Address);
   }
   case Builtin::BI__builtin_memmove: {
@@ -296,16 +307,16 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     Builder.CreateCall4(CGM.getMemMoveFn(), Address,
                         EmitScalarExpr(E->getArg(1)),
                         EmitScalarExpr(E->getArg(2)),
-                        llvm::ConstantInt::get(llvm::Type::Int32Ty, 1));
+                        llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1));
     return RValue::get(Address);
   }
   case Builtin::BI__builtin_memset: {
     Value *Address = EmitScalarExpr(E->getArg(0));
     Builder.CreateCall4(CGM.getMemSetFn(), Address,
                         Builder.CreateTrunc(EmitScalarExpr(E->getArg(1)),
-                                            llvm::Type::Int8Ty),
+                                            llvm::Type::getInt8Ty(VMContext)),
                         EmitScalarExpr(E->getArg(2)),
-                        llvm::ConstantInt::get(llvm::Type::Int32Ty, 1));
+                        llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1));
     return RValue::get(Address);
   }
   case Builtin::BI__builtin_return_address: {
@@ -332,20 +343,18 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     Value *FrameAddrF = CGM.getIntrinsic(Intrinsic::frameaddress, 0, 0);
     Value *FrameAddr =
         Builder.CreateCall(FrameAddrF,
-                           Constant::getNullValue(llvm::Type::Int32Ty));
+                           Constant::getNullValue(llvm::Type::getInt32Ty(VMContext)));
     Builder.CreateStore(FrameAddr, Buf);
     // Call the setjmp intrinsic
     Value *F = CGM.getIntrinsic(Intrinsic::eh_sjlj_setjmp, 0, 0);
-    const llvm::Type *DestType =
-      llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
+    const llvm::Type *DestType = llvm::Type::getInt8PtrTy(VMContext);
     Buf = Builder.CreateBitCast(Buf, DestType);
     return RValue::get(Builder.CreateCall(F, Buf));
   }
   case Builtin::BI__builtin_longjmp: {
     Value *F = CGM.getIntrinsic(Intrinsic::eh_sjlj_longjmp, 0, 0);
     Value *Buf = EmitScalarExpr(E->getArg(0));
-    const llvm::Type *DestType = 
-      llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
+    const llvm::Type *DestType = llvm::Type::getInt8PtrTy(VMContext);
     Buf = Builder.CreateBitCast(Buf, DestType);
     return RValue::get(Builder.CreateCall(F, Buf));
   }
@@ -401,7 +410,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
   case Builtin::BI__sync_fetch_and_nand_8:
   case Builtin::BI__sync_fetch_and_nand_16:
     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_nand, E);
-      
+
   // Clang extensions: not overloaded yet.
   case Builtin::BI__sync_fetch_and_min:
     return EmitBinaryAtomic(*this, Intrinsic::atomic_load_min, E);
@@ -417,7 +426,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
   case Builtin::BI__sync_add_and_fetch_4:
   case Builtin::BI__sync_add_and_fetch_8:
   case Builtin::BI__sync_add_and_fetch_16:
-    return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_add, E, 
+    return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_add, E,
                                 llvm::Instruction::Add);
   case Builtin::BI__sync_sub_and_fetch_1:
   case Builtin::BI__sync_sub_and_fetch_2:
@@ -454,7 +463,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
   case Builtin::BI__sync_nand_and_fetch_16:
     return EmitBinaryAtomicPost(*this, Intrinsic::atomic_load_nand, E,
                                 llvm::Instruction::And);
-      
+
   case Builtin::BI__sync_val_compare_and_swap_1:
   case Builtin::BI__sync_val_compare_and_swap_2:
   case Builtin::BI__sync_val_compare_and_swap_4:
@@ -465,7 +474,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     ResType[0]= ConvertType(E->getType());
     ResType[1] = ConvertType(E->getArg(0)->getType());
     Value *AtomF = CGM.getIntrinsic(Intrinsic::atomic_cmp_swap, ResType, 2);
-    return RValue::get(Builder.CreateCall3(AtomF, 
+    return RValue::get(Builder.CreateCall3(AtomF,
                                            EmitScalarExpr(E->getArg(0)),
                                            EmitScalarExpr(E->getArg(1)),
                                            EmitScalarExpr(E->getArg(2))));
@@ -482,7 +491,7 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     ResType[1] = llvm::PointerType::getUnqual(ResType[0]);
     Value *AtomF = CGM.getIntrinsic(Intrinsic::atomic_cmp_swap, ResType, 2);
     Value *OldVal = EmitScalarExpr(E->getArg(1));
-    Value *PrevVal = Builder.CreateCall3(AtomF, 
+    Value *PrevVal = Builder.CreateCall3(AtomF,
                                         EmitScalarExpr(E->getArg(0)),
                                         OldVal,
                                         EmitScalarExpr(E->getArg(2)));
@@ -511,12 +520,12 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
 
   case Builtin::BI__sync_synchronize: {
     Value *C[5];
-    C[0] = C[1] = C[2] = C[3] = llvm::ConstantInt::get(llvm::Type::Int1Ty, 1);
-    C[4] = ConstantInt::get(llvm::Type::Int1Ty, 0);
+    C[0] = C[1] = C[2] = C[3] = llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), 1);
+    C[4] = llvm::ConstantInt::get(llvm::Type::getInt1Ty(VMContext), 0);
     Builder.CreateCall(CGM.getIntrinsic(Intrinsic::memory_barrier), C, C + 5);
     return RValue::get(0);
   }
-      
+
     // Library functions with special handling.
   case Builtin::BIsqrt:
   case Builtin::BIsqrtf:
@@ -543,29 +552,31 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
     return RValue::get(Builder.CreateCall2(F, Base, Exponent, "tmp"));
   }
   }
-  
+
   // If this is an alias for a libm function (e.g. __builtin_sin) turn it into
   // that function.
   if (getContext().BuiltinInfo.isLibFunction(BuiltinID) ||
       getContext().BuiltinInfo.isPredefinedLibFunction(BuiltinID))
-    return EmitCall(CGM.getBuiltinLibFunction(BuiltinID), 
+    return EmitCall(CGM.getBuiltinLibFunction(FD, BuiltinID),
                     E->getCallee()->getType(), E->arg_begin(),
                     E->arg_end());
-  
+
   // See if we have a target specific intrinsic.
   const char *Name = getContext().BuiltinInfo.GetName(BuiltinID);
-  Intrinsic::ID IntrinsicID =
-    Intrinsic::getIntrinsicForGCCBuiltin(Target.getTargetPrefix(), Name);
-  
+  Intrinsic::ID IntrinsicID = Intrinsic::not_intrinsic;
+  if (const char *Prefix =
+      llvm::Triple::getArchTypePrefix(Target.getTriple().getArch()))
+    IntrinsicID = Intrinsic::getIntrinsicForGCCBuiltin(Prefix, Name);
+
   if (IntrinsicID != Intrinsic::not_intrinsic) {
     SmallVector<Value*, 16> Args;
-    
+
     Function *F = CGM.getIntrinsic(IntrinsicID);
     const llvm::FunctionType *FTy = F->getFunctionType();
-    
+
     for (unsigned i = 0, e = E->getNumArgs(); i != e; ++i) {
       Value *ArgValue = EmitScalarExpr(E->getArg(i));
-      
+
       // If the intrinsic arg type is different from the builtin arg type
       // we need to do a bit cast.
       const llvm::Type *PTy = FTy->getParamType(i);
@@ -574,50 +585,54 @@ RValue CodeGenFunction::EmitBuiltinExpr(const FunctionDecl *FD,
                "Must be able to losslessly bit cast to param");
         ArgValue = Builder.CreateBitCast(ArgValue, PTy);
       }
-      
+
       Args.push_back(ArgValue);
     }
-    
+
     Value *V = Builder.CreateCall(F, Args.data(), Args.data() + Args.size());
     QualType BuiltinRetType = E->getType();
-    
-    const llvm::Type *RetTy = llvm::Type::VoidTy;
+
+    const llvm::Type *RetTy = llvm::Type::getVoidTy(VMContext);
     if (!BuiltinRetType->isVoidType()) RetTy = ConvertType(BuiltinRetType);
-    
+
     if (RetTy != V->getType()) {
       assert(V->getType()->canLosslesslyBitCastTo(RetTy) &&
              "Must be able to losslessly bit cast result type");
       V = Builder.CreateBitCast(V, RetTy);
     }
-    
+
     return RValue::get(V);
   }
-  
+
   // See if we have a target specific builtin that needs to be lowered.
   if (Value *V = EmitTargetBuiltinExpr(BuiltinID, E))
     return RValue::get(V);
-  
+
   ErrorUnsupported(E, "builtin function");
-  
+
   // Unknown builtin, for now just dump it out and return undef.
   if (hasAggregateLLVMType(E->getType()))
     return RValue::getAggregate(CreateTempAlloca(ConvertType(E->getType())));
-  return RValue::get(UndefValue::get(ConvertType(E->getType())));
-}    
+  return RValue::get(llvm::UndefValue::get(ConvertType(E->getType())));
+}
 
 Value *CodeGenFunction::EmitTargetBuiltinExpr(unsigned BuiltinID,
                                               const CallExpr *E) {
-  const char *TargetPrefix = Target.getTargetPrefix();
-  if (strcmp(TargetPrefix, "x86") == 0)
+  switch (Target.getTriple().getArch()) {
+  case llvm::Triple::x86:
+  case llvm::Triple::x86_64:
     return EmitX86BuiltinExpr(BuiltinID, E);
-  else if (strcmp(TargetPrefix, "ppc") == 0)
+  case llvm::Triple::ppc:
+  case llvm::Triple::ppc64:
     return EmitPPCBuiltinExpr(BuiltinID, E);
-  return 0;
+  default:
+    return 0;
+  }
 }
 
-Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID, 
+Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
                                            const CallExpr *E) {
-  
+
   llvm::SmallVector<Value*, 4> Ops;
 
   for (unsigned i = 0, e = E->getNumArgs(); i != e; i++)
@@ -625,23 +640,23 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
 
   switch (BuiltinID) {
   default: return 0;
-  case X86::BI__builtin_ia32_pslldi128: 
+  case X86::BI__builtin_ia32_pslldi128:
   case X86::BI__builtin_ia32_psllqi128:
-  case X86::BI__builtin_ia32_psllwi128: 
+  case X86::BI__builtin_ia32_psllwi128:
   case X86::BI__builtin_ia32_psradi128:
   case X86::BI__builtin_ia32_psrawi128:
   case X86::BI__builtin_ia32_psrldi128:
   case X86::BI__builtin_ia32_psrlqi128:
   case X86::BI__builtin_ia32_psrlwi128: {
-    Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::Int64Ty, "zext");
-    const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::Int64Ty, 2);
-    llvm::Value *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
+    Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::getInt64Ty(VMContext), "zext");
+    const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::getInt64Ty(VMContext), 2);
+    llvm::Value *Zero = llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 0);
     Ops[1] = Builder.CreateInsertElement(llvm::UndefValue::get(Ty),
                                          Ops[1], Zero, "insert");
     Ops[1] = Builder.CreateBitCast(Ops[1], Ops[0]->getType(), "bitcast");
     const char *name = 0;
     Intrinsic::ID ID = Intrinsic::not_intrinsic;
-    
+
     switch (BuiltinID) {
     default: assert(0 && "Unsupported shift intrinsic!");
     case X86::BI__builtin_ia32_pslldi128:
@@ -678,22 +693,22 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
       break;
     }
     llvm::Function *F = CGM.getIntrinsic(ID);
-    return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);  
+    return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
   }
-  case X86::BI__builtin_ia32_pslldi: 
+  case X86::BI__builtin_ia32_pslldi:
   case X86::BI__builtin_ia32_psllqi:
-  case X86::BI__builtin_ia32_psllwi: 
+  case X86::BI__builtin_ia32_psllwi:
   case X86::BI__builtin_ia32_psradi:
   case X86::BI__builtin_ia32_psrawi:
   case X86::BI__builtin_ia32_psrldi:
   case X86::BI__builtin_ia32_psrlqi:
   case X86::BI__builtin_ia32_psrlwi: {
-    Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::Int64Ty, "zext");
-    const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::Int64Ty, 1);
+    Ops[1] = Builder.CreateZExt(Ops[1], llvm::Type::getInt64Ty(VMContext), "zext");
+    const llvm::Type *Ty = llvm::VectorType::get(llvm::Type::getInt64Ty(VMContext), 1);
     Ops[1] = Builder.CreateBitCast(Ops[1], Ty, "bitcast");
     const char *name = 0;
     Intrinsic::ID ID = Intrinsic::not_intrinsic;
-    
+
     switch (BuiltinID) {
     default: assert(0 && "Unsupported shift intrinsic!");
     case X86::BI__builtin_ia32_pslldi:
@@ -730,7 +745,7 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
       break;
     }
     llvm::Function *F = CGM.getIntrinsic(ID);
-    return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);  
+    return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);
   }
   case X86::BI__builtin_ia32_cmpps: {
     llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ps);
@@ -741,17 +756,17 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
     return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "cmpss");
   }
   case X86::BI__builtin_ia32_ldmxcsr: {
-    llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
-    Value *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
-    Value *Tmp = Builder.CreateAlloca(llvm::Type::Int32Ty, One, "tmp");
+    const llvm::Type *PtrTy = llvm::Type::getInt8PtrTy(VMContext);
+    Value *One = llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1);
+    Value *Tmp = Builder.CreateAlloca(llvm::Type::getInt32Ty(VMContext), One, "tmp");
     Builder.CreateStore(Ops[0], Tmp);
     return Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_ldmxcsr),
                               Builder.CreateBitCast(Tmp, PtrTy));
   }
   case X86::BI__builtin_ia32_stmxcsr: {
-    llvm::Type *PtrTy = llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
-    Value *One = llvm::ConstantInt::get(llvm::Type::Int32Ty, 1);
-    Value *Tmp = Builder.CreateAlloca(llvm::Type::Int32Ty, One, "tmp");
+    const llvm::Type *PtrTy = llvm::Type::getInt8PtrTy(VMContext);
+    Value *One = llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 1);
+    Value *Tmp = Builder.CreateAlloca(llvm::Type::getInt32Ty(VMContext), One, "tmp");
     One = Builder.CreateCall(CGM.getIntrinsic(Intrinsic::x86_sse_stmxcsr),
                              Builder.CreateBitCast(Tmp, PtrTy));
     return Builder.CreateLoad(Tmp, "stmxcsr");
@@ -766,16 +781,16 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
   }
   case X86::BI__builtin_ia32_storehps:
   case X86::BI__builtin_ia32_storelps: {
-    const llvm::Type *EltTy = llvm::Type::Int64Ty;
+    const llvm::Type *EltTy = llvm::Type::getInt64Ty(VMContext);
     llvm::Type *PtrTy = llvm::PointerType::getUnqual(EltTy);
     llvm::Type *VecTy = llvm::VectorType::get(EltTy, 2);
-    
+
     // cast val v2i64
     Ops[1] = Builder.CreateBitCast(Ops[1], VecTy, "cast");
-    
+
     // extract (0, 1)
     unsigned Index = BuiltinID == X86::BI__builtin_ia32_storelps ? 0 : 1;
-    llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, Index);
+    llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Index);
     Ops[1] = Builder.CreateExtractElement(Ops[1], Idx, "extract");
 
     // cast pointer to i64 & store
@@ -785,9 +800,9 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
   }
 }
 
-Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID, 
+Value *CodeGenFunction::EmitPPCBuiltinExpr(unsigned BuiltinID,
                                            const CallExpr *E) {
   switch (BuiltinID) {
   default: return 0;
   }
-}  
+}