Import Clang r73021.

9 files changed, 83 insertions, 278 deletions

diff --git a/lib/AST/DeclObjC.cpp b/lib/AST/DeclObjC.cpp
index 21aefdd..60a96d0 100644
--- a/lib/AST/DeclObjC.cpp
+++ b/lib/AST/DeclObjC.cpp
@@ -156,16 +156,6 @@ ObjCIvarDecl *ObjCInterfaceDecl::lookupInstanceVariable(
       clsDeclared = ClassDecl;
       return I;
     }
-    // look into properties.
-    for (ObjCInterfaceDecl::prop_iterator I = ClassDecl->prop_begin(Context),
-         E = ClassDecl->prop_end(Context); I != E; ++I) {
-      ObjCPropertyDecl *PDecl = (*I);
-      if (ObjCIvarDecl *IV = PDecl->getPropertyIvarDecl())
-        if (IV->getIdentifier() == ID) {
-          clsDeclared = ClassDecl;
-          return IV;
-        }
-    }
     ClassDecl = ClassDecl->getSuperClass();
   }
   return NULL;
diff --git a/lib/CodeGen/ABIInfo.h b/lib/CodeGen/ABIInfo.h
index 44af0c4..58e5a77 100644
--- a/lib/CodeGen/ABIInfo.h
+++ b/lib/CodeGen/ABIInfo.h
@@ -44,6 +44,9 @@ namespace clang {
                  /// converted LLVM type. Complex and structure types
                  /// are passed using first class aggregates.
 
+      Extend,    /// Valid only for integer argument types. Same as 'direct'
+                 /// but also emit a zero/sign extension attribute.
+
       Indirect,  /// Pass the argument indirectly via a hidden pointer
                  /// with the specified alignment (0 indicates default
                  /// alignment).
@@ -79,6 +82,9 @@ namespace clang {
     static ABIArgInfo getDirect() {
       return ABIArgInfo(Direct);
     }
+    static ABIArgInfo getExtend() {
+      return ABIArgInfo(Extend);
+    }
     static ABIArgInfo getIgnore() {
       return ABIArgInfo(Ignore);
     }
@@ -94,6 +100,7 @@ namespace clang {
 
     Kind getKind() const { return TheKind; }
     bool isDirect() const { return TheKind == Direct; }
+    bool isExtend() const { return TheKind == Extend; }
     bool isIgnore() const { return TheKind == Ignore; }
     bool isCoerce() const { return TheKind == Coerce; }
     bool isIndirect() const { return TheKind == Indirect; }
diff --git a/lib/CodeGen/CGBuiltin.cpp b/lib/CodeGen/CGBuiltin.cpp
index d813bba..3c7c5e5 100644
--- a/lib/CodeGen/CGBuiltin.cpp
+++ b/lib/CodeGen/CGBuiltin.cpp
@@ -625,81 +625,6 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
 
   switch (BuiltinID) {
   default: return 0;
-  case X86::BI__builtin_ia32_mulps:
-    return Builder.CreateMul(Ops[0], Ops[1], "mulps");
-  case X86::BI__builtin_ia32_mulpd:
-    return Builder.CreateMul(Ops[0], Ops[1], "mulpd");
-  case X86::BI__builtin_ia32_pand:
-  case X86::BI__builtin_ia32_pand128:
-    return Builder.CreateAnd(Ops[0], Ops[1], "pand");
-  case X86::BI__builtin_ia32_por:
-  case X86::BI__builtin_ia32_por128:
-    return Builder.CreateOr(Ops[0], Ops[1], "por");
-  case X86::BI__builtin_ia32_pxor:
-  case X86::BI__builtin_ia32_pxor128:
-    return Builder.CreateXor(Ops[0], Ops[1], "pxor");
-  case X86::BI__builtin_ia32_pandn:
-  case X86::BI__builtin_ia32_pandn128:
-    Ops[0] = Builder.CreateNot(Ops[0], "tmp");
-    return Builder.CreateAnd(Ops[0], Ops[1], "pandn");
-  case X86::BI__builtin_ia32_paddb:
-  case X86::BI__builtin_ia32_paddb128:
-  case X86::BI__builtin_ia32_paddd:
-  case X86::BI__builtin_ia32_paddd128:
-  case X86::BI__builtin_ia32_paddq:
-  case X86::BI__builtin_ia32_paddq128:
-  case X86::BI__builtin_ia32_paddw:
-  case X86::BI__builtin_ia32_paddw128:
-  case X86::BI__builtin_ia32_addps:
-  case X86::BI__builtin_ia32_addpd:
-    return Builder.CreateAdd(Ops[0], Ops[1], "add");
-  case X86::BI__builtin_ia32_psubb:
-  case X86::BI__builtin_ia32_psubb128:
-  case X86::BI__builtin_ia32_psubd:
-  case X86::BI__builtin_ia32_psubd128:
-  case X86::BI__builtin_ia32_psubq:
-  case X86::BI__builtin_ia32_psubq128:
-  case X86::BI__builtin_ia32_psubw:
-  case X86::BI__builtin_ia32_psubw128:
-  case X86::BI__builtin_ia32_subps:
-  case X86::BI__builtin_ia32_subpd:
-    return Builder.CreateSub(Ops[0], Ops[1], "sub");
-  case X86::BI__builtin_ia32_divps:
-    return Builder.CreateFDiv(Ops[0], Ops[1], "divps");
-  case X86::BI__builtin_ia32_divpd:
-    return Builder.CreateFDiv(Ops[0], Ops[1], "divpd");
-  case X86::BI__builtin_ia32_pmullw:
-  case X86::BI__builtin_ia32_pmullw128:
-    return Builder.CreateMul(Ops[0], Ops[1], "pmul");
-  case X86::BI__builtin_ia32_punpckhbw:
-    return EmitShuffleVector(Ops[0], Ops[1], 4, 12, 5, 13, 6, 14, 7, 15,
-                             "punpckhbw");
-  case X86::BI__builtin_ia32_punpckhbw128:
-    return EmitShuffleVector(Ops[0], Ops[1],  8, 24,  9, 25, 10, 26, 11, 27,
-                                             12, 28, 13, 29, 14, 30, 15, 31,
-                             "punpckhbw");
-  case X86::BI__builtin_ia32_punpckhwd:
-    return EmitShuffleVector(Ops[0], Ops[1], 2, 6, 3, 7, "punpckhwd");
-  case X86::BI__builtin_ia32_punpckhwd128:
-    return EmitShuffleVector(Ops[0], Ops[1], 4, 12, 5, 13, 6, 14, 7, 15,
-                             "punpckhwd");
-  case X86::BI__builtin_ia32_punpckhdq:
-    return EmitShuffleVector(Ops[0], Ops[1], 1, 3, "punpckhdq");
-  case X86::BI__builtin_ia32_punpckhdq128:
-    return EmitShuffleVector(Ops[0], Ops[1], 2, 6, 3, 7, "punpckhdq");
-  case X86::BI__builtin_ia32_punpckhqdq128:
-    return EmitShuffleVector(Ops[0], Ops[1], 1, 3, "punpckhqdq");
-  case X86::BI__builtin_ia32_punpcklbw:
-    return EmitShuffleVector(Ops[0], Ops[1], 0, 8, 1, 9, 2, 10, 3, 11,
-                             "punpcklbw");
-  case X86::BI__builtin_ia32_punpcklwd:
-    return EmitShuffleVector(Ops[0], Ops[1], 0, 4, 1, 5, "punpcklwd");
-  case X86::BI__builtin_ia32_punpckldq:
-    return EmitShuffleVector(Ops[0], Ops[1], 0, 2, "punpckldq");
-  case X86::BI__builtin_ia32_punpckldq128:
-    return EmitShuffleVector(Ops[0], Ops[1], 0, 4, 1, 5, "punpckldq");
-  case X86::BI__builtin_ia32_punpcklqdq128:
-    return EmitShuffleVector(Ops[0], Ops[1], 0, 2, "punpcklqdq");
   case X86::BI__builtin_ia32_pslldi128: 
   case X86::BI__builtin_ia32_psllqi128:
   case X86::BI__builtin_ia32_psllwi128: 
@@ -807,46 +732,6 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
     llvm::Function *F = CGM.getIntrinsic(ID);
     return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), name);  
   }
-  case X86::BI__builtin_ia32_pshufw: {
-    unsigned i = cast<ConstantInt>(Ops[1])->getZExtValue();
-    return EmitShuffleVector(Ops[0], Ops[0],
-                             i & 0x3, (i & 0xc) >> 2,
-                             (i & 0x30) >> 4, (i & 0xc0) >> 6,
-                             "pshufw");
-  }
-  case X86::BI__builtin_ia32_pshuflw: {
-    unsigned i = cast<ConstantInt>(Ops[1])->getZExtValue();
-    return EmitShuffleVector(Ops[0], Ops[0], 
-                             i & 0x3, (i & 0xc) >> 2,
-                             (i & 0x30) >> 4, (i & 0xc0) >> 6, 4, 5, 6, 7,
-                             "pshuflw");
-  }
-  case X86::BI__builtin_ia32_pshufhw: {
-    unsigned i = cast<ConstantInt>(Ops[1])->getZExtValue();
-    return EmitShuffleVector(Ops[0], Ops[0], 0, 1, 2, 3,
-                             4 + (i & 0x3), 4 + ((i & 0xc) >> 2),
-                             4 + ((i & 0x30) >> 4), 4 + ((i & 0xc0) >> 6),
-                             "pshufhw");
-  }
-  case X86::BI__builtin_ia32_pshufd: {
-    unsigned i = cast<ConstantInt>(Ops[1])->getZExtValue();
-    return EmitShuffleVector(Ops[0], Ops[0], 
-                             i & 0x3, (i & 0xc) >> 2,
-                             (i & 0x30) >> 4, (i & 0xc0) >> 6,
-                             "pshufd");
-  }
-  case X86::BI__builtin_ia32_vec_init_v4hi:
-  case X86::BI__builtin_ia32_vec_init_v8qi:
-  case X86::BI__builtin_ia32_vec_init_v2si:
-    return EmitVector(&Ops[0], Ops.size());
-  case X86::BI__builtin_ia32_vec_ext_v2si:
-  case X86::BI__builtin_ia32_vec_ext_v2di:
-  case X86::BI__builtin_ia32_vec_ext_v4sf:
-  case X86::BI__builtin_ia32_vec_ext_v4si:
-  case X86::BI__builtin_ia32_vec_ext_v8hi:
-  case X86::BI__builtin_ia32_vec_ext_v4hi:
-  case X86::BI__builtin_ia32_vec_ext_v2df:
-    return Builder.CreateExtractElement(Ops[0], Ops[1], "result");
   case X86::BI__builtin_ia32_cmpps: {
     llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse_cmp_ps);
     return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "cmpps");
@@ -879,63 +764,6 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
     llvm::Function *F = CGM.getIntrinsic(Intrinsic::x86_sse2_cmp_sd);
     return Builder.CreateCall(F, &Ops[0], &Ops[0] + Ops.size(), "cmpsd");
   }
-  case X86::BI__builtin_ia32_movss:
-    return EmitShuffleVector(Ops[0], Ops[1], 4, 1, 2, 3, "movss");
-  case X86::BI__builtin_ia32_shufps: {
-    unsigned i = cast<ConstantInt>(Ops[2])->getZExtValue();
-    return EmitShuffleVector(Ops[0], Ops[1], 
-                             i & 0x3, (i & 0xc) >> 2, 
-                             ((i & 0x30) >> 4) + 4, 
-                             ((i & 0xc0) >> 6) + 4, "shufps");
-  }
-  case X86::BI__builtin_ia32_shufpd: {
-    unsigned i = cast<ConstantInt>(Ops[2])->getZExtValue();
-    return EmitShuffleVector(Ops[0], Ops[1], i & 1,
-                             ((i & 2) >> 1)+2, "shufpd");
-  }
-  case X86::BI__builtin_ia32_punpcklbw128:
-    return EmitShuffleVector(Ops[0], Ops[1], 0, 16, 1, 17, 2, 18, 3, 19,
-                                             4, 20, 5, 21, 6, 22, 7, 23,
-                                             "punpcklbw");
-  case X86::BI__builtin_ia32_punpcklwd128:
-    return EmitShuffleVector(Ops[0], Ops[1], 0, 8, 1, 9, 2, 10, 3, 11,
-                             "punpcklwd");
-  case X86::BI__builtin_ia32_movlhps:
-    return EmitShuffleVector(Ops[0], Ops[1], 0, 1, 4, 5, "movlhps");
-  case X86::BI__builtin_ia32_movhlps:
-    return EmitShuffleVector(Ops[0], Ops[1], 6, 7, 2, 3, "movhlps");
-  case X86::BI__builtin_ia32_unpckhps:
-    return EmitShuffleVector(Ops[0], Ops[1], 2, 6, 3, 7, "unpckhps");
-  case X86::BI__builtin_ia32_unpcklps:
-    return EmitShuffleVector(Ops[0], Ops[1], 0, 4, 1, 5, "unpcklps");
-  case X86::BI__builtin_ia32_unpckhpd:
-    return EmitShuffleVector(Ops[0], Ops[1], 1, 3, "unpckhpd");
-  case X86::BI__builtin_ia32_unpcklpd:
-    return EmitShuffleVector(Ops[0], Ops[1], 0, 2, "unpcklpd");
-  case X86::BI__builtin_ia32_movsd:
-    return EmitShuffleVector(Ops[0], Ops[1], 2, 1, "movsd");
-  case X86::BI__builtin_ia32_loadlps:
-  case X86::BI__builtin_ia32_loadhps: {
-    // FIXME: This should probably be represented as 
-    // shuffle (dst, (v4f32 (insert undef, (load i64), 0)), shuf mask hi/lo)
-    const llvm::Type *EltTy = llvm::Type::DoubleTy;
-    const llvm::Type *VecTy = llvm::VectorType::get(EltTy, 2);
-    const llvm::Type *OrigTy = Ops[0]->getType();
-    unsigned Index = BuiltinID == X86::BI__builtin_ia32_loadlps ? 0 : 1;
-    llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, Index);
-    Ops[1] = Builder.CreateBitCast(Ops[1], llvm::PointerType::getUnqual(EltTy));
-    Ops[1] = Builder.CreateLoad(Ops[1], "tmp");
-    Ops[0] = Builder.CreateBitCast(Ops[0], VecTy, "cast");
-    Ops[0] = Builder.CreateInsertElement(Ops[0], Ops[1], Idx, "loadps");
-    return Builder.CreateBitCast(Ops[0], OrigTy, "loadps");
-  }
-  case X86::BI__builtin_ia32_loadlpd:
-  case X86::BI__builtin_ia32_loadhpd: {
-    Ops[1] = Builder.CreateLoad(Ops[1], "tmp");
-    unsigned Index = BuiltinID == X86::BI__builtin_ia32_loadlpd ? 0 : 1;
-    llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, Index);
-    return Builder.CreateInsertElement(Ops[0], Ops[1], Idx, "loadpd");
-  }
   case X86::BI__builtin_ia32_storehps:
   case X86::BI__builtin_ia32_storelps: {
     const llvm::Type *EltTy = llvm::Type::Int64Ty;
@@ -977,55 +805,6 @@ Value *CodeGenFunction::EmitX86BuiltinExpr(unsigned BuiltinID,
     return Builder.CreateBitCast(Ops[0], 
                                  llvm::VectorType::get(llvm::Type::Int32Ty, 4));
   }
-  case X86::BI__builtin_ia32_vec_set_v4hi:
-  case X86::BI__builtin_ia32_vec_set_v8hi:
-    return Builder.CreateInsertElement(Ops[0], Ops[1], Ops[2], "pinsrw");
-  case X86::BI__builtin_ia32_vec_set_v4si:
-    return Builder.CreateInsertElement(Ops[0], Ops[1], Ops[2], "pinsrd");
-  case X86::BI__builtin_ia32_vec_set_v2di:
-    return Builder.CreateInsertElement(Ops[0], Ops[1], Ops[2], "pinsrq");
-  case X86::BI__builtin_ia32_andps:
-  case X86::BI__builtin_ia32_andpd:
-  case X86::BI__builtin_ia32_andnps:
-  case X86::BI__builtin_ia32_andnpd:
-  case X86::BI__builtin_ia32_orps:
-  case X86::BI__builtin_ia32_orpd:
-  case X86::BI__builtin_ia32_xorpd:
-  case X86::BI__builtin_ia32_xorps: {
-    const llvm::Type *ITy = llvm::VectorType::get(llvm::Type::Int32Ty, 4);
-    const llvm::Type *FTy = Ops[0]->getType();
-    Ops[0] = Builder.CreateBitCast(Ops[0], ITy, "bitcast");
-    Ops[1] = Builder.CreateBitCast(Ops[1], ITy, "bitcast");
-    switch (BuiltinID) {
-    case X86::BI__builtin_ia32_andps:
-      Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andps");
-      break;
-    case X86::BI__builtin_ia32_andpd:
-      Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andpd");
-      break;
-    case X86::BI__builtin_ia32_andnps:
-      Ops[0] = Builder.CreateNot(Ops[0], "not");
-      Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andnps");
-      break;
-    case X86::BI__builtin_ia32_andnpd:
-      Ops[0] = Builder.CreateNot(Ops[0], "not");
-      Ops[0] = Builder.CreateAnd(Ops[0], Ops[1], "andnpd");
-      break;
-    case X86::BI__builtin_ia32_orps:
-      Ops[0] = Builder.CreateOr(Ops[0], Ops[1], "orps");
-      break;
-    case X86::BI__builtin_ia32_orpd:
-      Ops[0] = Builder.CreateOr(Ops[0], Ops[1], "orpd");
-      break;
-    case X86::BI__builtin_ia32_xorps:
-      Ops[0] = Builder.CreateXor(Ops[0], Ops[1], "xorps");
-      break;
-    case X86::BI__builtin_ia32_xorpd:
-      Ops[0] = Builder.CreateXor(Ops[0], Ops[1], "xorpd");
-      break;
-    }
-    return Builder.CreateBitCast(Ops[0], FTy, "bitcast");
-  }
   }
 }
 
diff --git a/lib/CodeGen/CGCall.cpp b/lib/CodeGen/CGCall.cpp
index b46e860..b10b9c2 100644
--- a/lib/CodeGen/CGCall.cpp
+++ b/lib/CodeGen/CGCall.cpp
@@ -314,6 +314,7 @@ CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI, bool IsVariadic) {
   case ABIArgInfo::Expand:
     assert(0 && "Invalid ABI kind for return argument");
 
+  case ABIArgInfo::Extend:
   case ABIArgInfo::Direct:
     ResultType = ConvertType(RetTy);
     break;
@@ -353,7 +354,8 @@ CodeGenTypes::GetFunctionType(const CGFunctionInfo &FI, bool IsVariadic) {
       ArgTys.push_back(llvm::PointerType::getUnqual(LTy));
       break;
     }
-      
+
+    case ABIArgInfo::Extend:
     case ABIArgInfo::Direct:
       ArgTys.push_back(ConvertType(it->type));
       break;
@@ -394,14 +396,14 @@ void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI,
   unsigned Index = 1;
   const ABIArgInfo &RetAI = FI.getReturnInfo();
   switch (RetAI.getKind()) {
+  case ABIArgInfo::Extend:
+   if (RetTy->isSignedIntegerType()) {
+     RetAttrs |= llvm::Attribute::SExt;
+   } else if (RetTy->isUnsignedIntegerType()) {
+     RetAttrs |= llvm::Attribute::ZExt;
+   }
+   // FALLTHROUGH
   case ABIArgInfo::Direct:
-    if (RetTy->isPromotableIntegerType()) {
-      if (RetTy->isSignedIntegerType()) {
-        RetAttrs |= llvm::Attribute::SExt;
-      } else if (RetTy->isUnsignedIntegerType()) {
-        RetAttrs |= llvm::Attribute::ZExt;
-      }
-    }
     break;
 
   case ABIArgInfo::Indirect:
@@ -452,15 +454,15 @@ void CodeGenModule::ConstructAttributeList(const CGFunctionInfo &FI,
       FuncAttrs &= ~(llvm::Attribute::ReadOnly |
                      llvm::Attribute::ReadNone);
       break;
-      
+
+    case ABIArgInfo::Extend:
+     if (ParamType->isSignedIntegerType()) {
+       Attributes |= llvm::Attribute::SExt;
+     } else if (ParamType->isUnsignedIntegerType()) {
+       Attributes |= llvm::Attribute::ZExt;
+     }
+     // FALLS THROUGH
     case ABIArgInfo::Direct:
-      if (ParamType->isPromotableIntegerType()) {
-        if (ParamType->isSignedIntegerType()) {
-          Attributes |= llvm::Attribute::SExt;
-        } else if (ParamType->isUnsignedIntegerType()) {
-          Attributes |= llvm::Attribute::ZExt;
-        }
-      }
       if (RegParm > 0 &&
           (ParamType->isIntegerType() || ParamType->isPointerType())) {
         RegParm -=
@@ -536,7 +538,8 @@ void CodeGenFunction::EmitFunctionProlog(const CGFunctionInfo &FI,
       EmitParmDecl(*Arg, V);      
       break;
     }
-      
+
+    case ABIArgInfo::Extend:
     case ABIArgInfo::Direct: {
       assert(AI != Fn->arg_end() && "Argument mismatch!");
       llvm::Value* V = AI;
@@ -618,10 +621,10 @@ void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
   llvm::Value *RV = 0;
 
   // Functions with no result always return void.
-  if (ReturnValue) { 
+  if (ReturnValue) {
     QualType RetTy = FI.getReturnType();
     const ABIArgInfo &RetAI = FI.getReturnInfo();
-    
+
     switch (RetAI.getKind()) {
     case ABIArgInfo::Indirect:
       if (RetTy->isAnyComplexType()) {
@@ -630,11 +633,12 @@ void CodeGenFunction::EmitFunctionEpilog(const CGFunctionInfo &FI,
       } else if (CodeGenFunction::hasAggregateLLVMType(RetTy)) {
         EmitAggregateCopy(CurFn->arg_begin(), ReturnValue, RetTy);
       } else {
-        EmitStoreOfScalar(Builder.CreateLoad(ReturnValue), CurFn->arg_begin(), 
+        EmitStoreOfScalar(Builder.CreateLoad(ReturnValue), CurFn->arg_begin(),
                           false, RetTy);
       }
       break;
 
+    case ABIArgInfo::Extend:
     case ABIArgInfo::Direct:
       // The internal return value temp always will have
       // pointer-to-return-type type.
@@ -705,6 +709,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
       }
       break;
 
+    case ABIArgInfo::Extend:
     case ABIArgInfo::Direct:
       if (RV.isScalar()) {
         Args.push_back(RV.getScalarVal());
@@ -791,6 +796,7 @@ RValue CodeGenFunction::EmitCall(const CGFunctionInfo &CallInfo,
       return RValue::getAggregate(Args[0]);
     return RValue::get(EmitLoadOfScalar(Args[0], false, RetTy));
 
+  case ABIArgInfo::Extend:
   case ABIArgInfo::Direct:
     if (RetTy->isAnyComplexType()) {
       llvm::Value *Real = Builder.CreateExtractValue(CI, 0);
diff --git a/lib/CodeGen/CGExpr.cpp b/lib/CodeGen/CGExpr.cpp
index c5f2387..c52e6bd 100644
--- a/lib/CodeGen/CGExpr.cpp
+++ b/lib/CodeGen/CGExpr.cpp
@@ -843,14 +843,16 @@ LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
 LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
   // The index must always be an integer, which is not an aggregate.  Emit it.
   llvm::Value *Idx = EmitScalarExpr(E->getIdx());
-  
+  QualType IdxTy  = E->getIdx()->getType();
+  bool IdxSigned = IdxTy->isSignedIntegerType();
+
   // If the base is a vector type, then we are forming a vector element lvalue
   // with this subscript.
   if (E->getBase()->getType()->isVectorType()) {
     // Emit the vector as an lvalue to get its address.
     LValue LHS = EmitLValue(E->getBase());
     assert(LHS.isSimple() && "Can only subscript lvalue vectors here!");
-    // FIXME: This should properly sign/zero/extend or truncate Idx to i32.
+    Idx = Builder.CreateIntCast(Idx, llvm::Type::Int32Ty, IdxSigned, "vidx");
     return LValue::MakeVectorElt(LHS.getAddress(), Idx,
       E->getBase()->getType().getCVRQualifiers());
   }
@@ -859,8 +861,6 @@ LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
   llvm::Value *Base = EmitScalarExpr(E->getBase());
   
   // Extend or truncate the index type to 32 or 64-bits.
-  QualType IdxTy  = E->getIdx()->getType();
-  bool IdxSigned = IdxTy->isSignedIntegerType();
   unsigned IdxBitwidth = cast<llvm::IntegerType>(Idx->getType())->getBitWidth();
   if (IdxBitwidth != LLVMPointerWidth)
     Idx = Builder.CreateIntCast(Idx, llvm::IntegerType::get(LLVMPointerWidth),
diff --git a/lib/CodeGen/TargetABIInfo.cpp b/lib/CodeGen/TargetABIInfo.cpp
index 573ffed..6f7bea2 100644
--- a/lib/CodeGen/TargetABIInfo.cpp
+++ b/lib/CodeGen/TargetABIInfo.cpp
@@ -28,6 +28,9 @@ void ABIArgInfo::dump() const {
   case Direct:
     fprintf(stderr, "Direct");
     break;
+  case Extend:
+    fprintf(stderr, "Extend");
+    break;
   case Ignore:
     fprintf(stderr, "Ignore");
     break;
@@ -342,7 +345,8 @@ ABIArgInfo X86_32ABIInfo::classifyReturnType(QualType RetTy,
 
     return ABIArgInfo::getIndirect(0);
   } else {
-    return ABIArgInfo::getDirect();
+    return (RetTy->isPromotableIntegerType() ?
+            ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
   }
 }
 
@@ -371,7 +375,8 @@ ABIArgInfo X86_32ABIInfo::classifyArgumentType(QualType Ty,
 
     return ABIArgInfo::getIndirect(0);
   } else {
-    return ABIArgInfo::getDirect();
+    return (Ty->isPromotableIntegerType() ?
+            ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
   }
 }
 
@@ -750,8 +755,8 @@ ABIArgInfo X86_64ABIInfo::getCoerceResult(QualType Ty,
     // Integer and pointer types will end up in a general purpose
     // register.
     if (Ty->isIntegralType() || Ty->isPointerType())
-      return ABIArgInfo::getDirect();
-
+      return (Ty->isPromotableIntegerType() ?
+              ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
   } else if (CoerceTo == llvm::Type::DoubleTy) {
     // FIXME: It would probably be better to make CGFunctionInfo only map using
     // canonical types than to canonize here.
@@ -771,7 +776,8 @@ ABIArgInfo X86_64ABIInfo::getIndirectResult(QualType Ty,
   // If this is a scalar LLVM value then assume LLVM will pass it in the right
   // place naturally.
   if (!CodeGenFunction::hasAggregateLLVMType(Ty))
-    return ABIArgInfo::getDirect();
+    return (Ty->isPromotableIntegerType() ?
+            ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
 
   // FIXME: Set alignment correctly.
   return ABIArgInfo::getIndirect(0);
@@ -1267,7 +1273,8 @@ void ARMABIInfo::computeInfo(CGFunctionInfo &FI, ASTContext &Context) const {
 ABIArgInfo ARMABIInfo::classifyArgumentType(QualType Ty,
                                             ASTContext &Context) const {
   if (!CodeGenFunction::hasAggregateLLVMType(Ty)) {
-    return ABIArgInfo::getDirect();
+    return (Ty->isPromotableIntegerType() ?
+            ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
   }
   // FIXME: This is kind of nasty... but there isn't much choice because the ARM
   // backend doesn't support byval.
@@ -1299,7 +1306,8 @@ ABIArgInfo ARMABIInfo::classifyReturnType(QualType RetTy,
       return ABIArgInfo::getCoerce(llvm::Type::Int32Ty);
     return ABIArgInfo::getIndirect(0);
   } else {
-    return ABIArgInfo::getDirect();
+    return (RetTy->isPromotableIntegerType() ?
+            ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
   }
 }
 
@@ -1335,7 +1343,8 @@ ABIArgInfo DefaultABIInfo::classifyReturnType(QualType RetTy,
   } else if (CodeGenFunction::hasAggregateLLVMType(RetTy)) {
     return ABIArgInfo::getIndirect(0);
   } else {
-    return ABIArgInfo::getDirect();
+    return (RetTy->isPromotableIntegerType() ?
+            ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
   }
 }
 
@@ -1344,7 +1353,8 @@ ABIArgInfo DefaultABIInfo::classifyArgumentType(QualType Ty,
   if (CodeGenFunction::hasAggregateLLVMType(Ty)) {
     return ABIArgInfo::getIndirect(0);
   } else {
-    return ABIArgInfo::getDirect();
+    return (Ty->isPromotableIntegerType() ?
+            ABIArgInfo::getExtend() : ABIArgInfo::getDirect());
   }
 }
 
diff --git a/lib/Headers/CMakeLists.txt b/lib/Headers/CMakeLists.txt
index 3c42167..e44c37a 100644
--- a/lib/Headers/CMakeLists.txt
+++ b/lib/Headers/CMakeLists.txt
@@ -1,12 +1,21 @@
 set(files
-  iso646.h
-  mmintrin.h
-  stdarg.h
-  stdbool.h
-  stddef.h
-  )
+  emmintrin.h	
+  float.h		
+  iso646.h	
+  limits.h	
+  mm_malloc.h	
+  mmintrin.h	
+  pmmintrin.h	
+  stdarg.h	
+  stdbool.h	
+  stddef.h	
+  stdint.h	
+  tgmath.h
+  tmmintrin.h
+  xmmintrin.h)
 
-set(output_dir ${CMAKE_RUNTIME_OUTPUT_DIRECTORY}/../Headers)
+#FIXME: Centralize Clang version info
+set(output_dir ${LLVM_BINARY_DIR}/${CMAKE_CFG_INTDIR}/lib/clang/1.0/include)
 
 foreach( f ${files} )
   set( src ${CMAKE_CURRENT_SOURCE_DIR}/${f} )
diff --git a/lib/Headers/xmmintrin.h b/lib/Headers/xmmintrin.h
index 7291f88..4938399 100644
--- a/lib/Headers/xmmintrin.h
+++ b/lib/Headers/xmmintrin.h
@@ -464,20 +464,19 @@ _mm_cvtss_f32(__m128 a)
 static inline __m128 __attribute__((__always_inline__, __nodebug__))
 _mm_loadh_pi(__m128 a, __m64 const *p)
 {
-  return __builtin_ia32_loadhps(a, (__v2si *)p);
+  __m128 b;
+  b[0] = *(float*)p;
+  b[1] = *((float*)p+1);
+  return __builtin_shufflevector(a, b, 0, 1, 4, 5);
 }
 
 static inline __m128 __attribute__((__always_inline__, __nodebug__))
 _mm_loadl_pi(__m128 a, __m64 const *p)
 {
-#if 0
-  // FIXME: This should work, but gives really crappy code at the moment
   __m128 b;
   b[0] = *(float*)p;
   b[1] = *((float*)p+1);
-  return __builtin_shufflevector(a, b, 0, 1, 4, 5);
-#endif
-  return __builtin_ia32_loadlps(a, (__v2si *)p);
+  return __builtin_shufflevector(a, b, 4, 5, 2, 3);
 }
 
 static inline __m128 __attribute__((__always_inline__, __nodebug__))
diff --git a/lib/Sema/SemaDeclObjC.cpp b/lib/Sema/SemaDeclObjC.cpp
index 2500a8f..5d47516 100644
--- a/lib/Sema/SemaDeclObjC.cpp
+++ b/lib/Sema/SemaDeclObjC.cpp
@@ -1996,10 +1996,15 @@ Sema::DeclPtrTy Sema::ActOnPropertyImplDecl(SourceLocation AtLoc,
     ObjCInterfaceDecl *ClassDeclared;
     Ivar = IDecl->lookupInstanceVariable(Context, PropertyIvar, ClassDeclared);
     if (!Ivar) {
-      Ivar = ObjCIvarDecl::Create(Context, CurContext, PropertyLoc, 
+      DeclContext *EnclosingContext = cast_or_null<DeclContext>(IDecl);
+      assert(EnclosingContext && 
+             "null DeclContext for synthesized ivar - ActOnPropertyImplDecl");
+      Ivar = ObjCIvarDecl::Create(Context, EnclosingContext, PropertyLoc, 
                                   PropertyIvar, PropType, 
                                   ObjCIvarDecl::Public,
                                   (Expr *)0);
+      Ivar->setLexicalDeclContext(IDecl);
+      IDecl->addDecl(Context, Ivar);
       property->setPropertyIvarDecl(Ivar);
       if (!getLangOptions().ObjCNonFragileABI)
         Diag(PropertyLoc, diag::error_missing_property_ivar_decl) << PropertyId;