lib/CodeGen/CGExpr.cpp

   1 //===--- CGExpr.cpp - Emit LLVM Code from Expressions ---------------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This contains code to emit Expr nodes as LLVM code.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CodeGenFunction.h"
  15 #include "CodeGenModule.h"
  16 #include "CGCall.h"
  17 #include "CGCXXABI.h"
  18 #include "CGRecordLayout.h"
  19 #include "CGObjCRuntime.h"
  20 #include "clang/AST/ASTContext.h"
  21 #include "clang/AST/DeclObjC.h"
  22 #include "llvm/Intrinsics.h"
  23 #include "clang/Frontend/CodeGenOptions.h"
  24 #include "llvm/Target/TargetData.h"
  25 using namespace clang;
  26 using namespace CodeGen;
  27
  28 //===--------------------------------------------------------------------===//
  29 //                        Miscellaneous Helper Methods
  30 //===--------------------------------------------------------------------===//
  31
  32 llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) {
  33   unsigned addressSpace =
  34     cast<llvm::PointerType>(value->getType())->getAddressSpace();
  35
  36   const llvm::PointerType *destType = Int8PtrTy;
  37   if (addressSpace)
  38     destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace);
  39
  40   if (value->getType() == destType) return value;
  41   return Builder.CreateBitCast(value, destType);
  42 }
  43
  44 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
  45 /// block.
  46 llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(const llvm::Type *Ty,
  47                                                     const llvm::Twine &Name) {
  48   if (!Builder.isNamePreserving())
  49     return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt);
  50   return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt);
  51 }
  52
  53 void CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var,
  54                                      llvm::Value *Init) {
  55   llvm::StoreInst *Store = new llvm::StoreInst(Init, Var);
  56   llvm::BasicBlock *Block = AllocaInsertPt->getParent();
  57   Block->getInstList().insertAfter(&*AllocaInsertPt, Store);
  58 }
  59
  60 llvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty,
  61                                                 const llvm::Twine &Name) {
  62   llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name);
  63   // FIXME: Should we prefer the preferred type alignment here?
  64   CharUnits Align = getContext().getTypeAlignInChars(Ty);
  65   Alloc->setAlignment(Align.getQuantity());
  66   return Alloc;
  67 }
  68
  69 llvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty,
  70                                                  const llvm::Twine &Name) {
  71   llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name);
  72   // FIXME: Should we prefer the preferred type alignment here?
  73   CharUnits Align = getContext().getTypeAlignInChars(Ty);
  74   Alloc->setAlignment(Align.getQuantity());
  75   return Alloc;
  76 }
  77
  78 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
  79 /// expression and compare the result against zero, returning an Int1Ty value.
  80 llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
  81   if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) {
  82     llvm::Value *MemPtr = EmitScalarExpr(E);
  83     return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT);
  84   }
  85
  86   QualType BoolTy = getContext().BoolTy;
  87   if (!E->getType()->isAnyComplexType())
  88     return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy);
  89
  90   return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy);
  91 }
  92
  93 /// EmitIgnoredExpr - Emit code to compute the specified expression,
  94 /// ignoring the result.
  95 void CodeGenFunction::EmitIgnoredExpr(const Expr *E) {
  96   if (E->isRValue())
  97     return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true);
  98
  99   // Just emit it as an l-value and drop the result.
 100   EmitLValue(E);
 101 }
 102
 103 /// EmitAnyExpr - Emit code to compute the specified expression which
 104 /// can have any type.  The result is returned as an RValue struct.
 105 /// If this is an aggregate expression, AggSlot indicates where the
 106 /// result should be returned.
 107 RValue CodeGenFunction::EmitAnyExpr(const Expr *E, AggValueSlot AggSlot,
 108                                     bool IgnoreResult) {
 109   if (!hasAggregateLLVMType(E->getType()))
 110     return RValue::get(EmitScalarExpr(E, IgnoreResult));
 111   else if (E->getType()->isAnyComplexType())
 112     return RValue::getComplex(EmitComplexExpr(E, IgnoreResult, IgnoreResult));
 113
 114   EmitAggExpr(E, AggSlot, IgnoreResult);
 115   return AggSlot.asRValue();
 116 }
 117
 118 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
 119 /// always be accessible even if no aggregate location is provided.
 120 RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) {
 121   AggValueSlot AggSlot = AggValueSlot::ignored();
 122
 123   if (hasAggregateLLVMType(E->getType()) &&
 124       !E->getType()->isAnyComplexType())
 125     AggSlot = CreateAggTemp(E->getType(), "agg.tmp");
 126   return EmitAnyExpr(E, AggSlot);
 127 }
 128
 129 /// EmitAnyExprToMem - Evaluate an expression into a given memory
 130 /// location.
 131 void CodeGenFunction::EmitAnyExprToMem(const Expr *E,
 132                                        llvm::Value *Location,
 133                                        bool IsLocationVolatile,
 134                                        bool IsInit) {
 135   if (E->getType()->isComplexType())
 136     EmitComplexExprIntoAddr(E, Location, IsLocationVolatile);
 137   else if (hasAggregateLLVMType(E->getType()))
 138     EmitAggExpr(E, AggValueSlot::forAddr(Location, IsLocationVolatile, IsInit));
 139   else {
 140     RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false));
 141     LValue LV = MakeAddrLValue(Location, E->getType());
 142     EmitStoreThroughLValue(RV, LV, E->getType());
 143   }
 144 }
 145
 146 namespace {
 147 /// \brief An adjustment to be made to the temporary created when emitting a
 148 /// reference binding, which accesses a particular subobject of that temporary.
 149   struct SubobjectAdjustment {
 150     enum { DerivedToBaseAdjustment, FieldAdjustment } Kind;
 151
 152     union {
 153       struct {
 154         const CastExpr *BasePath;
 155         const CXXRecordDecl *DerivedClass;
 156       } DerivedToBase;
 157
 158       FieldDecl *Field;
 159     };
 160
 161     SubobjectAdjustment(const CastExpr *BasePath,
 162                         const CXXRecordDecl *DerivedClass)
 163       : Kind(DerivedToBaseAdjustment) {
 164       DerivedToBase.BasePath = BasePath;
 165       DerivedToBase.DerivedClass = DerivedClass;
 166     }
 167
 168     SubobjectAdjustment(FieldDecl *Field)
 169       : Kind(FieldAdjustment) {
 170       this->Field = Field;
 171     }
 172   };
 173 }
 174
 175 static llvm::Value *
 176 CreateReferenceTemporary(CodeGenFunction& CGF, QualType Type,
 177                          const NamedDecl *InitializedDecl) {
 178   if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
 179     if (VD->hasGlobalStorage()) {
 180       llvm::SmallString<256> Name;
 181       llvm::raw_svector_ostream Out(Name);
 182       CGF.CGM.getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Out);
 183       Out.flush();
 184
 185       const llvm::Type *RefTempTy = CGF.ConvertTypeForMem(Type);
 186
 187       // Create the reference temporary.
 188       llvm::GlobalValue *RefTemp =
 189         new llvm::GlobalVariable(CGF.CGM.getModule(),
 190                                  RefTempTy, /*isConstant=*/false,
 191                                  llvm::GlobalValue::InternalLinkage,
 192                                  llvm::Constant::getNullValue(RefTempTy),
 193                                  Name.str());
 194       return RefTemp;
 195     }
 196   }
 197
 198   return CGF.CreateMemTemp(Type, "ref.tmp");
 199 }
 200
 201 static llvm::Value *
 202 EmitExprForReferenceBinding(CodeGenFunction &CGF, const Expr *E,
 203                             llvm::Value *&ReferenceTemporary,
 204                             const CXXDestructorDecl *&ReferenceTemporaryDtor,
 205                             const NamedDecl *InitializedDecl) {
 206   if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E))
 207     E = DAE->getExpr();
 208
 209   if (const ExprWithCleanups *TE = dyn_cast<ExprWithCleanups>(E)) {
 210     CodeGenFunction::RunCleanupsScope Scope(CGF);
 211
 212     return EmitExprForReferenceBinding(CGF, TE->getSubExpr(),
 213                                        ReferenceTemporary,
 214                                        ReferenceTemporaryDtor,
 215                                        InitializedDecl);
 216   }
 217
 218   RValue RV;
 219   if (E->isGLValue()) {
 220     // Emit the expression as an lvalue.
 221     LValue LV = CGF.EmitLValue(E);
 222     if (LV.isSimple())
 223       return LV.getAddress();
 224
 225     // We have to load the lvalue.
 226     RV = CGF.EmitLoadOfLValue(LV, E->getType());
 227   } else {
 228     QualType ResultTy = E->getType();
 229
 230     llvm::SmallVector<SubobjectAdjustment, 2> Adjustments;
 231     while (true) {
 232       if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) {
 233         E = PE->getSubExpr();
 234         continue;
 235       }
 236
 237       if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
 238         if ((CE->getCastKind() == CK_DerivedToBase ||
 239              CE->getCastKind() == CK_UncheckedDerivedToBase) &&
 240             E->getType()->isRecordType()) {
 241           E = CE->getSubExpr();
 242           CXXRecordDecl *Derived
 243             = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
 244           Adjustments.push_back(SubobjectAdjustment(CE, Derived));
 245           continue;
 246         }
 247
 248         if (CE->getCastKind() == CK_NoOp) {
 249           E = CE->getSubExpr();
 250           continue;
 251         }
 252       } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
 253         if (!ME->isArrow() && ME->getBase()->isRValue()) {
 254           assert(ME->getBase()->getType()->isRecordType());
 255           if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
 256             E = ME->getBase();
 257             Adjustments.push_back(SubobjectAdjustment(Field));
 258             continue;
 259           }
 260         }
 261       }
 262
 263       // Nothing changed.
 264       break;
 265     }
 266
 267     // Create a reference temporary if necessary.
 268     AggValueSlot AggSlot = AggValueSlot::ignored();
 269     if (CGF.hasAggregateLLVMType(E->getType()) &&
 270         !E->getType()->isAnyComplexType()) {
 271       ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
 272                                                     InitializedDecl);
 273       AggSlot = AggValueSlot::forAddr(ReferenceTemporary, false,
 274                                       InitializedDecl != 0);
 275     }
 276
 277     RV = CGF.EmitAnyExpr(E, AggSlot);
 278
 279     if (InitializedDecl) {
 280       // Get the destructor for the reference temporary.
 281       if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
 282         CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RT->getDecl());
 283         if (!ClassDecl->hasTrivialDestructor())
 284           ReferenceTemporaryDtor = ClassDecl->getDestructor();
 285       }
 286     }
 287
 288     // Check if need to perform derived-to-base casts and/or field accesses, to
 289     // get from the temporary object we created (and, potentially, for which we
 290     // extended the lifetime) to the subobject we're binding the reference to.
 291     if (!Adjustments.empty()) {
 292       llvm::Value *Object = RV.getAggregateAddr();
 293       for (unsigned I = Adjustments.size(); I != 0; --I) {
 294         SubobjectAdjustment &Adjustment = Adjustments[I-1];
 295         switch (Adjustment.Kind) {
 296         case SubobjectAdjustment::DerivedToBaseAdjustment:
 297           Object =
 298               CGF.GetAddressOfBaseClass(Object,
 299                                         Adjustment.DerivedToBase.DerivedClass,
 300                               Adjustment.DerivedToBase.BasePath->path_begin(),
 301                               Adjustment.DerivedToBase.BasePath->path_end(),
 302                                         /*NullCheckValue=*/false);
 303           break;
 304
 305         case SubobjectAdjustment::FieldAdjustment: {
 306           LValue LV =
 307             CGF.EmitLValueForField(Object, Adjustment.Field, 0);
 308           if (LV.isSimple()) {
 309             Object = LV.getAddress();
 310             break;
 311           }
 312
 313           // For non-simple lvalues, we actually have to create a copy of
 314           // the object we're binding to.
 315           QualType T = Adjustment.Field->getType().getNonReferenceType()
 316                                                   .getUnqualifiedType();
 317           Object = CreateReferenceTemporary(CGF, T, InitializedDecl);
 318           LValue TempLV = CGF.MakeAddrLValue(Object,
 319                                              Adjustment.Field->getType());
 320           CGF.EmitStoreThroughLValue(CGF.EmitLoadOfLValue(LV, T), TempLV, T);
 321           break;
 322         }
 323
 324         }
 325       }
 326
 327       const llvm::Type *ResultPtrTy = CGF.ConvertType(ResultTy)->getPointerTo();
 328       return CGF.Builder.CreateBitCast(Object, ResultPtrTy, "temp");
 329     }
 330   }
 331
 332   if (RV.isAggregate())
 333     return RV.getAggregateAddr();
 334
 335   // Create a temporary variable that we can bind the reference to.
 336   ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
 337                                                 InitializedDecl);
 338
 339
 340   unsigned Alignment =
 341     CGF.getContext().getTypeAlignInChars(E->getType()).getQuantity();
 342   if (RV.isScalar())
 343     CGF.EmitStoreOfScalar(RV.getScalarVal(), ReferenceTemporary,
 344                           /*Volatile=*/false, Alignment, E->getType());
 345   else
 346     CGF.StoreComplexToAddr(RV.getComplexVal(), ReferenceTemporary,
 347                            /*Volatile=*/false);
 348   return ReferenceTemporary;
 349 }
 350
 351 RValue
 352 CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E,
 353                                             const NamedDecl *InitializedDecl) {
 354   llvm::Value *ReferenceTemporary = 0;
 355   const CXXDestructorDecl *ReferenceTemporaryDtor = 0;
 356   llvm::Value *Value = EmitExprForReferenceBinding(*this, E, ReferenceTemporary,
 357                                                    ReferenceTemporaryDtor,
 358                                                    InitializedDecl);
 359   if (!ReferenceTemporaryDtor)
 360     return RValue::get(Value);
 361
 362   // Make sure to call the destructor for the reference temporary.
 363   if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
 364     if (VD->hasGlobalStorage()) {
 365       llvm::Constant *DtorFn =
 366         CGM.GetAddrOfCXXDestructor(ReferenceTemporaryDtor, Dtor_Complete);
 367       EmitCXXGlobalDtorRegistration(DtorFn,
 368                                     cast<llvm::Constant>(ReferenceTemporary));
 369
 370       return RValue::get(Value);
 371     }
 372   }
 373
 374   PushDestructorCleanup(ReferenceTemporaryDtor, ReferenceTemporary);
 375
 376   return RValue::get(Value);
 377 }
 378
 379
 380 /// getAccessedFieldNo - Given an encoded value and a result number, return the
 381 /// input field number being accessed.
 382 unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx,
 383                                              const llvm::Constant *Elts) {
 384   if (isa<llvm::ConstantAggregateZero>(Elts))
 385     return 0;
 386
 387   return cast<llvm::ConstantInt>(Elts->getOperand(Idx))->getZExtValue();
 388 }
 389
 390 void CodeGenFunction::EmitCheck(llvm::Value *Address, unsigned Size) {
 391   if (!CatchUndefined)
 392     return;
 393
 394   // This needs to be to the standard address space.
 395   Address = Builder.CreateBitCast(Address, Int8PtrTy);
 396
 397   const llvm::Type *IntPtrT = IntPtrTy;
 398   llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, &IntPtrT, 1);
 399
 400   // In time, people may want to control this and use a 1 here.
 401   llvm::Value *Arg = Builder.getFalse();
 402   llvm::Value *C = Builder.CreateCall2(F, Address, Arg);
 403   llvm::BasicBlock *Cont = createBasicBlock();
 404   llvm::BasicBlock *Check = createBasicBlock();
 405   llvm::Value *NegativeOne = llvm::ConstantInt::get(IntPtrTy, -1ULL);
 406   Builder.CreateCondBr(Builder.CreateICmpEQ(C, NegativeOne), Cont, Check);
 407
 408   EmitBlock(Check);
 409   Builder.CreateCondBr(Builder.CreateICmpUGE(C,
 410                                         llvm::ConstantInt::get(IntPtrTy, Size)),
 411                        Cont, getTrapBB());
 412   EmitBlock(Cont);
 413 }
 414
 415
 416 CodeGenFunction::ComplexPairTy CodeGenFunction::
 417 EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
 418                          bool isInc, bool isPre) {
 419   ComplexPairTy InVal = LoadComplexFromAddr(LV.getAddress(),
 420                                             LV.isVolatileQualified());
 421
 422   llvm::Value *NextVal;
 423   if (isa<llvm::IntegerType>(InVal.first->getType())) {
 424     uint64_t AmountVal = isInc ? 1 : -1;
 425     NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true);
 426
 427     // Add the inc/dec to the real part.
 428     NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
 429   } else {
 430     QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType();
 431     llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1);
 432     if (!isInc)
 433       FVal.changeSign();
 434     NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal);
 435
 436     // Add the inc/dec to the real part.
 437     NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
 438   }
 439
 440   ComplexPairTy IncVal(NextVal, InVal.second);
 441
 442   // Store the updated result through the lvalue.
 443   StoreComplexToAddr(IncVal, LV.getAddress(), LV.isVolatileQualified());
 444
 445   // If this is a postinc, return the value read from memory, otherwise use the
 446   // updated value.
 447   return isPre ? IncVal : InVal;
 448 }
 449
 450
 451 //===----------------------------------------------------------------------===//
 452 //                         LValue Expression Emission
 453 //===----------------------------------------------------------------------===//
 454
 455 RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
 456   if (Ty->isVoidType())
 457     return RValue::get(0);
 458
 459   if (const ComplexType *CTy = Ty->getAs<ComplexType>()) {
 460     const llvm::Type *EltTy = ConvertType(CTy->getElementType());
 461     llvm::Value *U = llvm::UndefValue::get(EltTy);
 462     return RValue::getComplex(std::make_pair(U, U));
 463   }
 464
 465   // If this is a use of an undefined aggregate type, the aggregate must have an
 466   // identifiable address.  Just because the contents of the value are undefined
 467   // doesn't mean that the address can't be taken and compared.
 468   if (hasAggregateLLVMType(Ty)) {
 469     llvm::Value *DestPtr = CreateMemTemp(Ty, "undef.agg.tmp");
 470     return RValue::getAggregate(DestPtr);
 471   }
 472
 473   return RValue::get(llvm::UndefValue::get(ConvertType(Ty)));
 474 }
 475
 476 RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
 477                                               const char *Name) {
 478   ErrorUnsupported(E, Name);
 479   return GetUndefRValue(E->getType());
 480 }
 481
 482 LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
 483                                               const char *Name) {
 484   ErrorUnsupported(E, Name);
 485   llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
 486   return MakeAddrLValue(llvm::UndefValue::get(Ty), E->getType());
 487 }
 488
 489 LValue CodeGenFunction::EmitCheckedLValue(const Expr *E) {
 490   LValue LV = EmitLValue(E);
 491   if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple())
 492     EmitCheck(LV.getAddress(),
 493               getContext().getTypeSizeInChars(E->getType()).getQuantity());
 494   return LV;
 495 }
 496
 497 /// EmitLValue - Emit code to compute a designator that specifies the location
 498 /// of the expression.
 499 ///
 500 /// This can return one of two things: a simple address or a bitfield reference.
 501 /// In either case, the LLVM Value* in the LValue structure is guaranteed to be
 502 /// an LLVM pointer type.
 503 ///
 504 /// If this returns a bitfield reference, nothing about the pointee type of the
 505 /// LLVM value is known: For example, it may not be a pointer to an integer.
 506 ///
 507 /// If this returns a normal address, and if the lvalue's C type is fixed size,
 508 /// this method guarantees that the returned pointer type will point to an LLVM
 509 /// type of the same size of the lvalue's type.  If the lvalue has a variable
 510 /// length type, this is not possible.
 511 ///
 512 LValue CodeGenFunction::EmitLValue(const Expr *E) {
 513   switch (E->getStmtClass()) {
 514   default: return EmitUnsupportedLValue(E, "l-value expression");
 515
 516   case Expr::ObjCSelectorExprClass:
 517   return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E));
 518   case Expr::ObjCIsaExprClass:
 519     return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E));
 520   case Expr::BinaryOperatorClass:
 521     return EmitBinaryOperatorLValue(cast<BinaryOperator>(E));
 522   case Expr::CompoundAssignOperatorClass:
 523     if (!E->getType()->isAnyComplexType())
 524       return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
 525     return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
 526   case Expr::CallExprClass:
 527   case Expr::CXXMemberCallExprClass:
 528   case Expr::CXXOperatorCallExprClass:
 529     return EmitCallExprLValue(cast<CallExpr>(E));
 530   case Expr::VAArgExprClass:
 531     return EmitVAArgExprLValue(cast<VAArgExpr>(E));
 532   case Expr::DeclRefExprClass:
 533     return EmitDeclRefLValue(cast<DeclRefExpr>(E));
 534   case Expr::ParenExprClass:return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
 535   case Expr::PredefinedExprClass:
 536     return EmitPredefinedLValue(cast<PredefinedExpr>(E));
 537   case Expr::StringLiteralClass:
 538     return EmitStringLiteralLValue(cast<StringLiteral>(E));
 539   case Expr::ObjCEncodeExprClass:
 540     return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E));
 541
 542   case Expr::BlockDeclRefExprClass:
 543     return EmitBlockDeclRefLValue(cast<BlockDeclRefExpr>(E));
 544
 545   case Expr::CXXTemporaryObjectExprClass:
 546   case Expr::CXXConstructExprClass:
 547     return EmitCXXConstructLValue(cast<CXXConstructExpr>(E));
 548   case Expr::CXXBindTemporaryExprClass:
 549     return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E));
 550   case Expr::ExprWithCleanupsClass:
 551     return EmitExprWithCleanupsLValue(cast<ExprWithCleanups>(E));
 552   case Expr::CXXScalarValueInitExprClass:
 553     return EmitNullInitializationLValue(cast<CXXScalarValueInitExpr>(E));
 554   case Expr::CXXDefaultArgExprClass:
 555     return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr());
 556   case Expr::CXXTypeidExprClass:
 557     return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
 558
 559   case Expr::ObjCMessageExprClass:
 560     return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E));
 561   case Expr::ObjCIvarRefExprClass:
 562     return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E));
 563   case Expr::ObjCPropertyRefExprClass:
 564     return EmitObjCPropertyRefLValue(cast<ObjCPropertyRefExpr>(E));
 565   case Expr::StmtExprClass:
 566     return EmitStmtExprLValue(cast<StmtExpr>(E));
 567   case Expr::UnaryOperatorClass:
 568     return EmitUnaryOpLValue(cast<UnaryOperator>(E));
 569   case Expr::ArraySubscriptExprClass:
 570     return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E));
 571   case Expr::ExtVectorElementExprClass:
 572     return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E));
 573   case Expr::MemberExprClass:
 574     return EmitMemberExpr(cast<MemberExpr>(E));
 575   case Expr::CompoundLiteralExprClass:
 576     return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
 577   case Expr::ConditionalOperatorClass:
 578     return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E));
 579   case Expr::BinaryConditionalOperatorClass:
 580     return EmitConditionalOperatorLValue(cast<BinaryConditionalOperator>(E));
 581   case Expr::ChooseExprClass:
 582     return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext()));
 583   case Expr::OpaqueValueExprClass:
 584     return EmitOpaqueValueLValue(cast<OpaqueValueExpr>(E));
 585   case Expr::ImplicitCastExprClass:
 586   case Expr::CStyleCastExprClass:
 587   case Expr::CXXFunctionalCastExprClass:
 588   case Expr::CXXStaticCastExprClass:
 589   case Expr::CXXDynamicCastExprClass:
 590   case Expr::CXXReinterpretCastExprClass:
 591   case Expr::CXXConstCastExprClass:
 592     return EmitCastLValue(cast<CastExpr>(E));
 593   }
 594 }
 595
 596 llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
 597                                               unsigned Alignment, QualType Ty,
 598                                               llvm::MDNode *TBAAInfo) {
 599   llvm::LoadInst *Load = Builder.CreateLoad(Addr, "tmp");
 600   if (Volatile)
 601     Load->setVolatile(true);
 602   if (Alignment)
 603     Load->setAlignment(Alignment);
 604   if (TBAAInfo)
 605     CGM.DecorateInstruction(Load, TBAAInfo);
 606
 607   return EmitFromMemory(Load, Ty);
 608 }
 609
 610 static bool isBooleanUnderlyingType(QualType Ty) {
 611   if (const EnumType *ET = dyn_cast<EnumType>(Ty))
 612     return ET->getDecl()->getIntegerType()->isBooleanType();
 613   return false;
 614 }
 615
 616 llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) {
 617   // Bool has a different representation in memory than in registers.
 618   if (Ty->isBooleanType() || isBooleanUnderlyingType(Ty)) {
 619     // This should really always be an i1, but sometimes it's already
 620     // an i8, and it's awkward to track those cases down.
 621     if (Value->getType()->isIntegerTy(1))
 622       return Builder.CreateZExt(Value, Builder.getInt8Ty(), "frombool");
 623     assert(Value->getType()->isIntegerTy(8) && "value rep of bool not i1/i8");
 624   }
 625
 626   return Value;
 627 }
 628
 629 llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) {
 630   // Bool has a different representation in memory than in registers.
 631   if (Ty->isBooleanType() || isBooleanUnderlyingType(Ty)) {
 632     assert(Value->getType()->isIntegerTy(8) && "memory rep of bool not i8");
 633     return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool");
 634   }
 635
 636   return Value;
 637 }
 638
 639 void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
 640                                         bool Volatile, unsigned Alignment,
 641                                         QualType Ty,
 642                                         llvm::MDNode *TBAAInfo) {
 643   Value = EmitToMemory(Value, Ty);
 644   llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile);
 645   if (Alignment)
 646     Store->setAlignment(Alignment);
 647   if (TBAAInfo)
 648     CGM.DecorateInstruction(Store, TBAAInfo);
 649 }
 650
 651 /// EmitLoadOfLValue - Given an expression that represents a value lvalue, this
 652 /// method emits the address of the lvalue, then loads the result as an rvalue,
 653 /// returning the rvalue.
 654 RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, QualType ExprType) {
 655   if (LV.isObjCWeak()) {
 656     // load of a __weak object.
 657     llvm::Value *AddrWeakObj = LV.getAddress();
 658     return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this,
 659                                                              AddrWeakObj));
 660   }
 661
 662   if (LV.isSimple()) {
 663     llvm::Value *Ptr = LV.getAddress();
 664
 665     // Functions are l-values that don't require loading.
 666     if (ExprType->isFunctionType())
 667       return RValue::get(Ptr);
 668
 669     // Everything needs a load.
 670     return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(),
 671                                         LV.getAlignment(), ExprType,
 672                                         LV.getTBAAInfo()));
 673
 674   }
 675
 676   if (LV.isVectorElt()) {
 677     llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(),
 678                                           LV.isVolatileQualified(), "tmp");
 679     return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(),
 680                                                     "vecext"));
 681   }
 682
 683   // If this is a reference to a subset of the elements of a vector, either
 684   // shuffle the input or extract/insert them as appropriate.
 685   if (LV.isExtVectorElt())
 686     return EmitLoadOfExtVectorElementLValue(LV, ExprType);
 687
 688   if (LV.isBitField())
 689     return EmitLoadOfBitfieldLValue(LV, ExprType);
 690
 691   assert(LV.isPropertyRef() && "Unknown LValue type!");
 692   return EmitLoadOfPropertyRefLValue(LV);
 693 }
 694
 695 RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV,
 696                                                  QualType ExprType) {
 697   const CGBitFieldInfo &Info = LV.getBitFieldInfo();
 698
 699   // Get the output type.
 700   const llvm::Type *ResLTy = ConvertType(ExprType);
 701   unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
 702
 703   // Compute the result as an OR of all of the individual component accesses.
 704   llvm::Value *Res = 0;
 705   for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
 706     const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
 707
 708     // Get the field pointer.
 709     llvm::Value *Ptr = LV.getBitFieldBaseAddr();
 710
 711     // Only offset by the field index if used, so that incoming values are not
 712     // required to be structures.
 713     if (AI.FieldIndex)
 714       Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
 715
 716     // Offset by the byte offset, if used.
 717     if (AI.FieldByteOffset) {
 718       Ptr = EmitCastToVoidPtr(Ptr);
 719       Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset,"bf.field.offs");
 720     }
 721
 722     // Cast to the access type.
 723     const llvm::Type *PTy = llvm::Type::getIntNPtrTy(getLLVMContext(),
 724                                                      AI.AccessWidth,
 725                                                     ExprType.getAddressSpace());
 726     Ptr = Builder.CreateBitCast(Ptr, PTy);
 727
 728     // Perform the load.
 729     llvm::LoadInst *Load = Builder.CreateLoad(Ptr, LV.isVolatileQualified());
 730     if (AI.AccessAlignment)
 731       Load->setAlignment(AI.AccessAlignment);
 732
 733     // Shift out unused low bits and mask out unused high bits.
 734     llvm::Value *Val = Load;
 735     if (AI.FieldBitStart)
 736       Val = Builder.CreateLShr(Load, AI.FieldBitStart);
 737     Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(AI.AccessWidth,
 738                                                             AI.TargetBitWidth),
 739                             "bf.clear");
 740
 741     // Extend or truncate to the target size.
 742     if (AI.AccessWidth < ResSizeInBits)
 743       Val = Builder.CreateZExt(Val, ResLTy);
 744     else if (AI.AccessWidth > ResSizeInBits)
 745       Val = Builder.CreateTrunc(Val, ResLTy);
 746
 747     // Shift into place, and OR into the result.
 748     if (AI.TargetBitOffset)
 749       Val = Builder.CreateShl(Val, AI.TargetBitOffset);
 750     Res = Res ? Builder.CreateOr(Res, Val) : Val;
 751   }
 752
 753   // If the bit-field is signed, perform the sign-extension.
 754   //
 755   // FIXME: This can easily be folded into the load of the high bits, which
 756   // could also eliminate the mask of high bits in some situations.
 757   if (Info.isSigned()) {
 758     unsigned ExtraBits = ResSizeInBits - Info.getSize();
 759     if (ExtraBits)
 760       Res = Builder.CreateAShr(Builder.CreateShl(Res, ExtraBits),
 761                                ExtraBits, "bf.val.sext");
 762   }
 763
 764   return RValue::get(Res);
 765 }
 766
 767 // If this is a reference to a subset of the elements of a vector, create an
 768 // appropriate shufflevector.
 769 RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV,
 770                                                          QualType ExprType) {
 771   llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(),
 772                                         LV.isVolatileQualified(), "tmp");
 773
 774   const llvm::Constant *Elts = LV.getExtVectorElts();
 775
 776   // If the result of the expression is a non-vector type, we must be extracting
 777   // a single element.  Just codegen as an extractelement.
 778   const VectorType *ExprVT = ExprType->getAs<VectorType>();
 779   if (!ExprVT) {
 780     unsigned InIdx = getAccessedFieldNo(0, Elts);
 781     llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
 782     return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp"));
 783   }
 784
 785   // Always use shuffle vector to try to retain the original program structure
 786   unsigned NumResultElts = ExprVT->getNumElements();
 787
 788   llvm::SmallVector<llvm::Constant*, 4> Mask;
 789   for (unsigned i = 0; i != NumResultElts; ++i) {
 790     unsigned InIdx = getAccessedFieldNo(i, Elts);
 791     Mask.push_back(llvm::ConstantInt::get(Int32Ty, InIdx));
 792   }
 793
 794   llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
 795   Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()),
 796                                     MaskV, "tmp");
 797   return RValue::get(Vec);
 798 }
 799
 800
 801
 802 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
 803 /// lvalue, where both are guaranteed to the have the same type, and that type
 804 /// is 'Ty'.
 805 void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst,
 806                                              QualType Ty) {
 807   if (!Dst.isSimple()) {
 808     if (Dst.isVectorElt()) {
 809       // Read/modify/write the vector, inserting the new element.
 810       llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(),
 811                                             Dst.isVolatileQualified(), "tmp");
 812       Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
 813                                         Dst.getVectorIdx(), "vecins");
 814       Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified());
 815       return;
 816     }
 817
 818     // If this is an update of extended vector elements, insert them as
 819     // appropriate.
 820     if (Dst.isExtVectorElt())
 821       return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty);
 822
 823     if (Dst.isBitField())
 824       return EmitStoreThroughBitfieldLValue(Src, Dst, Ty);
 825
 826     assert(Dst.isPropertyRef() && "Unknown LValue type");
 827     return EmitStoreThroughPropertyRefLValue(Src, Dst);
 828   }
 829
 830   if (Dst.isObjCWeak() && !Dst.isNonGC()) {
 831     // load of a __weak object.
 832     llvm::Value *LvalueDst = Dst.getAddress();
 833     llvm::Value *src = Src.getScalarVal();
 834      CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst);
 835     return;
 836   }
 837
 838   if (Dst.isObjCStrong() && !Dst.isNonGC()) {
 839     // load of a __strong object.
 840     llvm::Value *LvalueDst = Dst.getAddress();
 841     llvm::Value *src = Src.getScalarVal();
 842     if (Dst.isObjCIvar()) {
 843       assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL");
 844       const llvm::Type *ResultType = ConvertType(getContext().LongTy);
 845       llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp());
 846       llvm::Value *dst = RHS;
 847       RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
 848       llvm::Value *LHS =
 849         Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast");
 850       llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset");
 851       CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst,
 852                                               BytesBetween);
 853     } else if (Dst.isGlobalObjCRef()) {
 854       CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst,
 855                                                 Dst.isThreadLocalRef());
 856     }
 857     else
 858       CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst);
 859     return;
 860   }
 861
 862   assert(Src.isScalar() && "Can't emit an agg store with this method");
 863   EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(),
 864                     Dst.isVolatileQualified(), Dst.getAlignment(), Ty,
 865                     Dst.getTBAAInfo());
 866 }
 867
 868 void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
 869                                                      QualType Ty,
 870                                                      llvm::Value **Result) {
 871   const CGBitFieldInfo &Info = Dst.getBitFieldInfo();
 872
 873   // Get the output type.
 874   const llvm::Type *ResLTy = ConvertTypeForMem(Ty);
 875   unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
 876
 877   // Get the source value, truncated to the width of the bit-field.
 878   llvm::Value *SrcVal = Src.getScalarVal();
 879
 880   if (Ty->isBooleanType())
 881     SrcVal = Builder.CreateIntCast(SrcVal, ResLTy, /*IsSigned=*/false);
 882
 883   SrcVal = Builder.CreateAnd(SrcVal, llvm::APInt::getLowBitsSet(ResSizeInBits,
 884                                                                 Info.getSize()),
 885                              "bf.value");
 886
 887   // Return the new value of the bit-field, if requested.
 888   if (Result) {
 889     // Cast back to the proper type for result.
 890     const llvm::Type *SrcTy = Src.getScalarVal()->getType();
 891     llvm::Value *ReloadVal = Builder.CreateIntCast(SrcVal, SrcTy, false,
 892                                                    "bf.reload.val");
 893
 894     // Sign extend if necessary.
 895     if (Info.isSigned()) {
 896       unsigned ExtraBits = ResSizeInBits - Info.getSize();
 897       if (ExtraBits)
 898         ReloadVal = Builder.CreateAShr(Builder.CreateShl(ReloadVal, ExtraBits),
 899                                        ExtraBits, "bf.reload.sext");
 900     }
 901
 902     *Result = ReloadVal;
 903   }
 904
 905   // Iterate over the components, writing each piece to memory.
 906   for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
 907     const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
 908
 909     // Get the field pointer.
 910     llvm::Value *Ptr = Dst.getBitFieldBaseAddr();
 911     unsigned addressSpace =
 912       cast<llvm::PointerType>(Ptr->getType())->getAddressSpace();
 913
 914     // Only offset by the field index if used, so that incoming values are not
 915     // required to be structures.
 916     if (AI.FieldIndex)
 917       Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
 918
 919     // Offset by the byte offset, if used.
 920     if (AI.FieldByteOffset) {
 921       Ptr = EmitCastToVoidPtr(Ptr);
 922       Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset,"bf.field.offs");
 923     }
 924
 925     // Cast to the access type.
 926     const llvm::Type *AccessLTy =
 927       llvm::Type::getIntNTy(getLLVMContext(), AI.AccessWidth);
 928
 929     const llvm::Type *PTy = AccessLTy->getPointerTo(addressSpace);
 930     Ptr = Builder.CreateBitCast(Ptr, PTy);
 931
 932     // Extract the piece of the bit-field value to write in this access, limited
 933     // to the values that are part of this access.
 934     llvm::Value *Val = SrcVal;
 935     if (AI.TargetBitOffset)
 936       Val = Builder.CreateLShr(Val, AI.TargetBitOffset);
 937     Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(ResSizeInBits,
 938                                                             AI.TargetBitWidth));
 939
 940     // Extend or truncate to the access size.
 941     if (ResSizeInBits < AI.AccessWidth)
 942       Val = Builder.CreateZExt(Val, AccessLTy);
 943     else if (ResSizeInBits > AI.AccessWidth)
 944       Val = Builder.CreateTrunc(Val, AccessLTy);
 945
 946     // Shift into the position in memory.
 947     if (AI.FieldBitStart)
 948       Val = Builder.CreateShl(Val, AI.FieldBitStart);
 949
 950     // If necessary, load and OR in bits that are outside of the bit-field.
 951     if (AI.TargetBitWidth != AI.AccessWidth) {
 952       llvm::LoadInst *Load = Builder.CreateLoad(Ptr, Dst.isVolatileQualified());
 953       if (AI.AccessAlignment)
 954         Load->setAlignment(AI.AccessAlignment);
 955
 956       // Compute the mask for zeroing the bits that are part of the bit-field.
 957       llvm::APInt InvMask =
 958         ~llvm::APInt::getBitsSet(AI.AccessWidth, AI.FieldBitStart,
 959                                  AI.FieldBitStart + AI.TargetBitWidth);
 960
 961       // Apply the mask and OR in to the value to write.
 962       Val = Builder.CreateOr(Builder.CreateAnd(Load, InvMask), Val);
 963     }
 964
 965     // Write the value.
 966     llvm::StoreInst *Store = Builder.CreateStore(Val, Ptr,
 967                                                  Dst.isVolatileQualified());
 968     if (AI.AccessAlignment)
 969       Store->setAlignment(AI.AccessAlignment);
 970   }
 971 }
 972
 973 void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
 974                                                                LValue Dst,
 975                                                                QualType Ty) {
 976   // This access turns into a read/modify/write of the vector.  Load the input
 977   // value now.
 978   llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(),
 979                                         Dst.isVolatileQualified(), "tmp");
 980   const llvm::Constant *Elts = Dst.getExtVectorElts();
 981
 982   llvm::Value *SrcVal = Src.getScalarVal();
 983
 984   if (const VectorType *VTy = Ty->getAs<VectorType>()) {
 985     unsigned NumSrcElts = VTy->getNumElements();
 986     unsigned NumDstElts =
 987        cast<llvm::VectorType>(Vec->getType())->getNumElements();
 988     if (NumDstElts == NumSrcElts) {
 989       // Use shuffle vector is the src and destination are the same number of
 990       // elements and restore the vector mask since it is on the side it will be
 991       // stored.
 992       llvm::SmallVector<llvm::Constant*, 4> Mask(NumDstElts);
 993       for (unsigned i = 0; i != NumSrcElts; ++i) {
 994         unsigned InIdx = getAccessedFieldNo(i, Elts);
 995         Mask[InIdx] = llvm::ConstantInt::get(Int32Ty, i);
 996       }
 997
 998       llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
 999       Vec = Builder.CreateShuffleVector(SrcVal,
1000                                         llvm::UndefValue::get(Vec->getType()),
1001                                         MaskV, "tmp");
1002     } else if (NumDstElts > NumSrcElts) {
1003       // Extended the source vector to the same length and then shuffle it
1004       // into the destination.
1005       // FIXME: since we're shuffling with undef, can we just use the indices
1006       //        into that?  This could be simpler.
1007       llvm::SmallVector<llvm::Constant*, 4> ExtMask;
1008       unsigned i;
1009       for (i = 0; i != NumSrcElts; ++i)
1010         ExtMask.push_back(llvm::ConstantInt::get(Int32Ty, i));
1011       for (; i != NumDstElts; ++i)
1012         ExtMask.push_back(llvm::UndefValue::get(Int32Ty));
1013       llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask);
1014       llvm::Value *ExtSrcVal =
1015         Builder.CreateShuffleVector(SrcVal,
1016                                     llvm::UndefValue::get(SrcVal->getType()),
1017                                     ExtMaskV, "tmp");
1018       // build identity
1019       llvm::SmallVector<llvm::Constant*, 4> Mask;
1020       for (unsigned i = 0; i != NumDstElts; ++i)
1021         Mask.push_back(llvm::ConstantInt::get(Int32Ty, i));
1022
1023       // modify when what gets shuffled in
1024       for (unsigned i = 0; i != NumSrcElts; ++i) {
1025         unsigned Idx = getAccessedFieldNo(i, Elts);
1026         Mask[Idx] = llvm::ConstantInt::get(Int32Ty, i+NumDstElts);
1027       }
1028       llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1029       Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp");
1030     } else {
1031       // We should never shorten the vector
1032       assert(0 && "unexpected shorten vector length");
1033     }
1034   } else {
1035     // If the Src is a scalar (not a vector) it must be updating one element.
1036     unsigned InIdx = getAccessedFieldNo(0, Elts);
1037     llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
1038     Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp");
1039   }
1040
1041   Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified());
1042 }
1043
1044 // setObjCGCLValueClass - sets class of he lvalue for the purpose of
1045 // generating write-barries API. It is currently a global, ivar,
1046 // or neither.
1047 static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E,
1048                                  LValue &LV) {
1049   if (Ctx.getLangOptions().getGCMode() == LangOptions::NonGC)
1050     return;
1051
1052   if (isa<ObjCIvarRefExpr>(E)) {
1053     LV.setObjCIvar(true);
1054     ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E));
1055     LV.setBaseIvarExp(Exp->getBase());
1056     LV.setObjCArray(E->getType()->isArrayType());
1057     return;
1058   }
1059
1060   if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) {
1061     if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
1062       if (VD->hasGlobalStorage()) {
1063         LV.setGlobalObjCRef(true);
1064         LV.setThreadLocalRef(VD->isThreadSpecified());
1065       }
1066     }
1067     LV.setObjCArray(E->getType()->isArrayType());
1068     return;
1069   }
1070
1071   if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) {
1072     setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
1073     return;
1074   }
1075
1076   if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) {
1077     setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
1078     if (LV.isObjCIvar()) {
1079       // If cast is to a structure pointer, follow gcc's behavior and make it
1080       // a non-ivar write-barrier.
1081       QualType ExpTy = E->getType();
1082       if (ExpTy->isPointerType())
1083         ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1084       if (ExpTy->isRecordType())
1085         LV.setObjCIvar(false);
1086     }
1087     return;
1088   }
1089   if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) {
1090     setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
1091     return;
1092   }
1093
1094   if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) {
1095     setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV);
1096     return;
1097   }
1098
1099   if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
1100     setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
1101     if (LV.isObjCIvar() && !LV.isObjCArray())
1102       // Using array syntax to assigning to what an ivar points to is not
1103       // same as assigning to the ivar itself. {id *Names;} Names[i] = 0;
1104       LV.setObjCIvar(false);
1105     else if (LV.isGlobalObjCRef() && !LV.isObjCArray())
1106       // Using array syntax to assigning to what global points to is not
1107       // same as assigning to the global itself. {id *G;} G[i] = 0;
1108       LV.setGlobalObjCRef(false);
1109     return;
1110   }
1111
1112   if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) {
1113     setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
1114     // We don't know if member is an 'ivar', but this flag is looked at
1115     // only in the context of LV.isObjCIvar().
1116     LV.setObjCArray(E->getType()->isArrayType());
1117     return;
1118   }
1119 }
1120
1121 static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF,
1122                                       const Expr *E, const VarDecl *VD) {
1123   assert((VD->hasExternalStorage() || VD->isFileVarDecl()) &&
1124          "Var decl must have external storage or be a file var decl!");
1125
1126   llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD);
1127   if (VD->getType()->isReferenceType())
1128     V = CGF.Builder.CreateLoad(V, "tmp");
1129   unsigned Alignment = CGF.getContext().getDeclAlign(VD).getQuantity();
1130   LValue LV = CGF.MakeAddrLValue(V, E->getType(), Alignment);
1131   setObjCGCLValueClass(CGF.getContext(), E, LV);
1132   return LV;
1133 }
1134
1135 static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF,
1136                                       const Expr *E, const FunctionDecl *FD) {
1137   llvm::Value *V = CGF.CGM.GetAddrOfFunction(FD);
1138   if (!FD->hasPrototype()) {
1139     if (const FunctionProtoType *Proto =
1140             FD->getType()->getAs<FunctionProtoType>()) {
1141       // Ugly case: for a K&R-style definition, the type of the definition
1142       // isn't the same as the type of a use.  Correct for this with a
1143       // bitcast.
1144       QualType NoProtoType =
1145           CGF.getContext().getFunctionNoProtoType(Proto->getResultType());
1146       NoProtoType = CGF.getContext().getPointerType(NoProtoType);
1147       V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType), "tmp");
1148     }
1149   }
1150   unsigned Alignment = CGF.getContext().getDeclAlign(FD).getQuantity();
1151   return CGF.MakeAddrLValue(V, E->getType(), Alignment);
1152 }
1153
1154 LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
1155   const NamedDecl *ND = E->getDecl();
1156   unsigned Alignment = getContext().getDeclAlign(ND).getQuantity();
1157
1158   if (ND->hasAttr<WeakRefAttr>()) {
1159     const ValueDecl *VD = cast<ValueDecl>(ND);
1160     llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD);
1161     return MakeAddrLValue(Aliasee, E->getType(), Alignment);
1162   }
1163
1164   if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
1165
1166     // Check if this is a global variable.
1167     if (VD->hasExternalStorage() || VD->isFileVarDecl())
1168       return EmitGlobalVarDeclLValue(*this, E, VD);
1169
1170     bool NonGCable = VD->hasLocalStorage() &&
1171                      !VD->getType()->isReferenceType() &&
1172                      !VD->hasAttr<BlocksAttr>();
1173
1174     llvm::Value *V = LocalDeclMap[VD];
1175     if (!V && VD->isStaticLocal())
1176       V = CGM.getStaticLocalDeclAddress(VD);
1177     assert(V && "DeclRefExpr not entered in LocalDeclMap?");
1178
1179     if (VD->hasAttr<BlocksAttr>())
1180       V = BuildBlockByrefAddress(V, VD);
1181
1182     if (VD->getType()->isReferenceType())
1183       V = Builder.CreateLoad(V, "tmp");
1184
1185     LValue LV = MakeAddrLValue(V, E->getType(), Alignment);
1186     if (NonGCable) {
1187       LV.getQuals().removeObjCGCAttr();
1188       LV.setNonGC(true);
1189     }
1190     setObjCGCLValueClass(getContext(), E, LV);
1191     return LV;
1192   }
1193
1194   if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND))
1195     return EmitFunctionDeclLValue(*this, E, fn);
1196
1197   assert(false && "Unhandled DeclRefExpr");
1198
1199   // an invalid LValue, but the assert will
1200   // ensure that this point is never reached.
1201   return LValue();
1202 }
1203
1204 LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) {
1205   unsigned Alignment =
1206     getContext().getDeclAlign(E->getDecl()).getQuantity();
1207   return MakeAddrLValue(GetAddrOfBlockDecl(E), E->getType(), Alignment);
1208 }
1209
1210 LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
1211   // __extension__ doesn't affect lvalue-ness.
1212   if (E->getOpcode() == UO_Extension)
1213     return EmitLValue(E->getSubExpr());
1214
1215   QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType());
1216   switch (E->getOpcode()) {
1217   default: assert(0 && "Unknown unary operator lvalue!");
1218   case UO_Deref: {
1219     QualType T = E->getSubExpr()->getType()->getPointeeType();
1220     assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type");
1221
1222     LValue LV = MakeAddrLValue(EmitScalarExpr(E->getSubExpr()), T);
1223     LV.getQuals().setAddressSpace(ExprTy.getAddressSpace());
1224
1225     // We should not generate __weak write barrier on indirect reference
1226     // of a pointer to object; as in void foo (__weak id *param); *param = 0;
1227     // But, we continue to generate __strong write barrier on indirect write
1228     // into a pointer to object.
1229     if (getContext().getLangOptions().ObjC1 &&
1230         getContext().getLangOptions().getGCMode() != LangOptions::NonGC &&
1231         LV.isObjCWeak())
1232       LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
1233     return LV;
1234   }
1235   case UO_Real:
1236   case UO_Imag: {
1237     LValue LV = EmitLValue(E->getSubExpr());
1238     assert(LV.isSimple() && "real/imag on non-ordinary l-value");
1239     llvm::Value *Addr = LV.getAddress();
1240
1241     // real and imag are valid on scalars.  This is a faster way of
1242     // testing that.
1243     if (!cast<llvm::PointerType>(Addr->getType())
1244            ->getElementType()->isStructTy()) {
1245       assert(E->getSubExpr()->getType()->isArithmeticType());
1246       return LV;
1247     }
1248
1249     assert(E->getSubExpr()->getType()->isAnyComplexType());
1250
1251     unsigned Idx = E->getOpcode() == UO_Imag;
1252     return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(),
1253                                                   Idx, "idx"),
1254                           ExprTy);
1255   }
1256   case UO_PreInc:
1257   case UO_PreDec: {
1258     LValue LV = EmitLValue(E->getSubExpr());
1259     bool isInc = E->getOpcode() == UO_PreInc;
1260
1261     if (E->getType()->isAnyComplexType())
1262       EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/);
1263     else
1264       EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/);
1265     return LV;
1266   }
1267   }
1268 }
1269
1270 LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
1271   return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E),
1272                         E->getType());
1273 }
1274
1275 LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
1276   return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E),
1277                         E->getType());
1278 }
1279
1280
1281 LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
1282   switch (E->getIdentType()) {
1283   default:
1284     return EmitUnsupportedLValue(E, "predefined expression");
1285
1286   case PredefinedExpr::Func:
1287   case PredefinedExpr::Function:
1288   case PredefinedExpr::PrettyFunction: {
1289     unsigned Type = E->getIdentType();
1290     std::string GlobalVarName;
1291
1292     switch (Type) {
1293     default: assert(0 && "Invalid type");
1294     case PredefinedExpr::Func:
1295       GlobalVarName = "__func__.";
1296       break;
1297     case PredefinedExpr::Function:
1298       GlobalVarName = "__FUNCTION__.";
1299       break;
1300     case PredefinedExpr::PrettyFunction:
1301       GlobalVarName = "__PRETTY_FUNCTION__.";
1302       break;
1303     }
1304
1305     llvm::StringRef FnName = CurFn->getName();
1306     if (FnName.startswith("\01"))
1307       FnName = FnName.substr(1);
1308     GlobalVarName += FnName;
1309
1310     const Decl *CurDecl = CurCodeDecl;
1311     if (CurDecl == 0)
1312       CurDecl = getContext().getTranslationUnitDecl();
1313
1314     std::string FunctionName =
1315         (isa<BlockDecl>(CurDecl)
1316          ? FnName.str()
1317          : PredefinedExpr::ComputeName((PredefinedExpr::IdentType)Type, CurDecl));
1318
1319     llvm::Constant *C =
1320       CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str());
1321     return MakeAddrLValue(C, E->getType());
1322   }
1323   }
1324 }
1325
1326 llvm::BasicBlock *CodeGenFunction::getTrapBB() {
1327   const CodeGenOptions &GCO = CGM.getCodeGenOpts();
1328
1329   // If we are not optimzing, don't collapse all calls to trap in the function
1330   // to the same call, that way, in the debugger they can see which operation
1331   // did in fact fail.  If we are optimizing, we collapse all calls to trap down
1332   // to just one per function to save on codesize.
1333   if (GCO.OptimizationLevel && TrapBB)
1334     return TrapBB;
1335
1336   llvm::BasicBlock *Cont = 0;
1337   if (HaveInsertPoint()) {
1338     Cont = createBasicBlock("cont");
1339     EmitBranch(Cont);
1340   }
1341   TrapBB = createBasicBlock("trap");
1342   EmitBlock(TrapBB);
1343
1344   llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap, 0, 0);
1345   llvm::CallInst *TrapCall = Builder.CreateCall(F);
1346   TrapCall->setDoesNotReturn();
1347   TrapCall->setDoesNotThrow();
1348   Builder.CreateUnreachable();
1349
1350   if (Cont)
1351     EmitBlock(Cont);
1352   return TrapBB;
1353 }
1354
1355 /// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an
1356 /// array to pointer, return the array subexpression.
1357 static const Expr *isSimpleArrayDecayOperand(const Expr *E) {
1358   // If this isn't just an array->pointer decay, bail out.
1359   const CastExpr *CE = dyn_cast<CastExpr>(E);
1360   if (CE == 0 || CE->getCastKind() != CK_ArrayToPointerDecay)
1361     return 0;
1362
1363   // If this is a decay from variable width array, bail out.
1364   const Expr *SubExpr = CE->getSubExpr();
1365   if (SubExpr->getType()->isVariableArrayType())
1366     return 0;
1367
1368   return SubExpr;
1369 }
1370
1371 LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
1372   // The index must always be an integer, which is not an aggregate.  Emit it.
1373   llvm::Value *Idx = EmitScalarExpr(E->getIdx());
1374   QualType IdxTy  = E->getIdx()->getType();
1375   bool IdxSigned = IdxTy->isSignedIntegerType();
1376
1377   // If the base is a vector type, then we are forming a vector element lvalue
1378   // with this subscript.
1379   if (E->getBase()->getType()->isVectorType()) {
1380     // Emit the vector as an lvalue to get its address.
1381     LValue LHS = EmitLValue(E->getBase());
1382     assert(LHS.isSimple() && "Can only subscript lvalue vectors here!");
1383     Idx = Builder.CreateIntCast(Idx, Int32Ty, IdxSigned, "vidx");
1384     return LValue::MakeVectorElt(LHS.getAddress(), Idx,
1385                                  E->getBase()->getType().getCVRQualifiers());
1386   }
1387
1388   // Extend or truncate the index type to 32 or 64-bits.
1389   if (Idx->getType() != IntPtrTy)
1390     Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom");
1391
1392   // FIXME: As llvm implements the object size checking, this can come out.
1393   if (CatchUndefined) {
1394     if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E->getBase())){
1395       if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) {
1396         if (ICE->getCastKind() == CK_ArrayToPointerDecay) {
1397           if (const ConstantArrayType *CAT
1398               = getContext().getAsConstantArrayType(DRE->getType())) {
1399             llvm::APInt Size = CAT->getSize();
1400             llvm::BasicBlock *Cont = createBasicBlock("cont");
1401             Builder.CreateCondBr(Builder.CreateICmpULE(Idx,
1402                                   llvm::ConstantInt::get(Idx->getType(), Size)),
1403                                  Cont, getTrapBB());
1404             EmitBlock(Cont);
1405           }
1406         }
1407       }
1408     }
1409   }
1410
1411   // We know that the pointer points to a type of the correct size, unless the
1412   // size is a VLA or Objective-C interface.
1413   llvm::Value *Address = 0;
1414   if (const VariableArrayType *VAT =
1415         getContext().getAsVariableArrayType(E->getType())) {
1416     llvm::Value *VLASize = GetVLASize(VAT);
1417
1418     Idx = Builder.CreateMul(Idx, VLASize);
1419
1420     // The base must be a pointer, which is not an aggregate.  Emit it.
1421     llvm::Value *Base = EmitScalarExpr(E->getBase());
1422
1423     Address = EmitCastToVoidPtr(Base);
1424     Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx");
1425     Address = Builder.CreateBitCast(Address, Base->getType());
1426   } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){
1427     // Indexing over an interface, as in "NSString *P; P[4];"
1428     llvm::Value *InterfaceSize =
1429       llvm::ConstantInt::get(Idx->getType(),
1430           getContext().getTypeSizeInChars(OIT).getQuantity());
1431
1432     Idx = Builder.CreateMul(Idx, InterfaceSize);
1433
1434     // The base must be a pointer, which is not an aggregate.  Emit it.
1435     llvm::Value *Base = EmitScalarExpr(E->getBase());
1436     Address = EmitCastToVoidPtr(Base);
1437     Address = Builder.CreateGEP(Address, Idx, "arrayidx");
1438     Address = Builder.CreateBitCast(Address, Base->getType());
1439   } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
1440     // If this is A[i] where A is an array, the frontend will have decayed the
1441     // base to be a ArrayToPointerDecay implicit cast.  While correct, it is
1442     // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a
1443     // "gep x, i" here.  Emit one "gep A, 0, i".
1444     assert(Array->getType()->isArrayType() &&
1445            "Array to pointer decay must have array source type!");
1446     llvm::Value *ArrayPtr = EmitLValue(Array).getAddress();
1447     llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0);
1448     llvm::Value *Args[] = { Zero, Idx };
1449
1450     Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, Args+2, "arrayidx");
1451   } else {
1452     // The base must be a pointer, which is not an aggregate.  Emit it.
1453     llvm::Value *Base = EmitScalarExpr(E->getBase());
1454     Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
1455   }
1456
1457   QualType T = E->getBase()->getType()->getPointeeType();
1458   assert(!T.isNull() &&
1459          "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type");
1460
1461   LValue LV = MakeAddrLValue(Address, T);
1462   LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace());
1463
1464   if (getContext().getLangOptions().ObjC1 &&
1465       getContext().getLangOptions().getGCMode() != LangOptions::NonGC) {
1466     LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
1467     setObjCGCLValueClass(getContext(), E, LV);
1468   }
1469   return LV;
1470 }
1471
1472 static
1473 llvm::Constant *GenerateConstantVector(llvm::LLVMContext &VMContext,
1474                                        llvm::SmallVector<unsigned, 4> &Elts) {
1475   llvm::SmallVector<llvm::Constant*, 4> CElts;
1476
1477   const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext);
1478   for (unsigned i = 0, e = Elts.size(); i != e; ++i)
1479     CElts.push_back(llvm::ConstantInt::get(Int32Ty, Elts[i]));
1480
1481   return llvm::ConstantVector::get(CElts);
1482 }
1483
1484 LValue CodeGenFunction::
1485 EmitExtVectorElementExpr(const ExtVectorElementExpr *E) {
1486   // Emit the base vector as an l-value.
1487   LValue Base;
1488
1489   // ExtVectorElementExpr's base can either be a vector or pointer to vector.
1490   if (E->isArrow()) {
1491     // If it is a pointer to a vector, emit the address and form an lvalue with
1492     // it.
1493     llvm::Value *Ptr = EmitScalarExpr(E->getBase());
1494     const PointerType *PT = E->getBase()->getType()->getAs<PointerType>();
1495     Base = MakeAddrLValue(Ptr, PT->getPointeeType());
1496     Base.getQuals().removeObjCGCAttr();
1497   } else if (E->getBase()->isGLValue()) {
1498     // Otherwise, if the base is an lvalue ( as in the case of foo.x.x),
1499     // emit the base as an lvalue.
1500     assert(E->getBase()->getType()->isVectorType());
1501     Base = EmitLValue(E->getBase());
1502   } else {
1503     // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such.
1504     assert(E->getBase()->getType()->getAs<VectorType>() &&
1505            "Result must be a vector");
1506     llvm::Value *Vec = EmitScalarExpr(E->getBase());
1507
1508     // Store the vector to memory (because LValue wants an address).
1509     llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType());
1510     Builder.CreateStore(Vec, VecMem);
1511     Base = MakeAddrLValue(VecMem, E->getBase()->getType());
1512   }
1513
1514   // Encode the element access list into a vector of unsigned indices.
1515   llvm::SmallVector<unsigned, 4> Indices;
1516   E->getEncodedElementAccess(Indices);
1517
1518   if (Base.isSimple()) {
1519     llvm::Constant *CV = GenerateConstantVector(getLLVMContext(), Indices);
1520     return LValue::MakeExtVectorElt(Base.getAddress(), CV,
1521                                     Base.getVRQualifiers());
1522   }
1523   assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!");
1524
1525   llvm::Constant *BaseElts = Base.getExtVectorElts();
1526   llvm::SmallVector<llvm::Constant *, 4> CElts;
1527
1528   for (unsigned i = 0, e = Indices.size(); i != e; ++i) {
1529     if (isa<llvm::ConstantAggregateZero>(BaseElts))
1530       CElts.push_back(llvm::ConstantInt::get(Int32Ty, 0));
1531     else
1532       CElts.push_back(cast<llvm::Constant>(BaseElts->getOperand(Indices[i])));
1533   }
1534   llvm::Constant *CV = llvm::ConstantVector::get(CElts);
1535   return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV,
1536                                   Base.getVRQualifiers());
1537 }
1538
1539 LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
1540   bool isNonGC = false;
1541   Expr *BaseExpr = E->getBase();
1542   llvm::Value *BaseValue = NULL;
1543   Qualifiers BaseQuals;
1544
1545   // If this is s.x, emit s as an lvalue.  If it is s->x, emit s as a scalar.
1546   if (E->isArrow()) {
1547     BaseValue = EmitScalarExpr(BaseExpr);
1548     const PointerType *PTy =
1549       BaseExpr->getType()->getAs<PointerType>();
1550     BaseQuals = PTy->getPointeeType().getQualifiers();
1551   } else {
1552     LValue BaseLV = EmitLValue(BaseExpr);
1553     if (BaseLV.isNonGC())
1554       isNonGC = true;
1555     // FIXME: this isn't right for bitfields.
1556     BaseValue = BaseLV.getAddress();
1557     QualType BaseTy = BaseExpr->getType();
1558     BaseQuals = BaseTy.getQualifiers();
1559   }
1560
1561   NamedDecl *ND = E->getMemberDecl();
1562   if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) {
1563     LValue LV = EmitLValueForField(BaseValue, Field,
1564                                    BaseQuals.getCVRQualifiers());
1565     LV.setNonGC(isNonGC);
1566     setObjCGCLValueClass(getContext(), E, LV);
1567     return LV;
1568   }
1569
1570   if (VarDecl *VD = dyn_cast<VarDecl>(ND))
1571     return EmitGlobalVarDeclLValue(*this, E, VD);
1572
1573   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
1574     return EmitFunctionDeclLValue(*this, E, FD);
1575
1576   assert(false && "Unhandled member declaration!");
1577   return LValue();
1578 }
1579
1580 LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value *BaseValue,
1581                                               const FieldDecl *Field,
1582                                               unsigned CVRQualifiers) {
1583   const CGRecordLayout &RL =
1584     CGM.getTypes().getCGRecordLayout(Field->getParent());
1585   const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field);
1586   return LValue::MakeBitfield(BaseValue, Info,
1587                              Field->getType().getCVRQualifiers()|CVRQualifiers);
1588 }
1589
1590 /// EmitLValueForAnonRecordField - Given that the field is a member of
1591 /// an anonymous struct or union buried inside a record, and given
1592 /// that the base value is a pointer to the enclosing record, derive
1593 /// an lvalue for the ultimate field.
1594 LValue CodeGenFunction::EmitLValueForAnonRecordField(llvm::Value *BaseValue,
1595                                              const IndirectFieldDecl *Field,
1596                                                      unsigned CVRQualifiers) {
1597   IndirectFieldDecl::chain_iterator I = Field->chain_begin(),
1598     IEnd = Field->chain_end();
1599   while (true) {
1600     LValue LV = EmitLValueForField(BaseValue, cast<FieldDecl>(*I), CVRQualifiers);
1601     if (++I == IEnd) return LV;
1602
1603     assert(LV.isSimple());
1604     BaseValue = LV.getAddress();
1605     CVRQualifiers |= LV.getVRQualifiers();
1606   }
1607 }
1608
1609 LValue CodeGenFunction::EmitLValueForField(llvm::Value *BaseValue,
1610                                            const FieldDecl *Field,
1611                                            unsigned CVRQualifiers) {
1612   if (Field->isBitField())
1613     return EmitLValueForBitfield(BaseValue, Field, CVRQualifiers);
1614
1615   const CGRecordLayout &RL =
1616     CGM.getTypes().getCGRecordLayout(Field->getParent());
1617   unsigned idx = RL.getLLVMFieldNo(Field);
1618   llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp");
1619
1620   // Match union field type.
1621   if (Field->getParent()->isUnion()) {
1622     const llvm::Type *FieldTy =
1623       CGM.getTypes().ConvertTypeForMem(Field->getType());
1624     const llvm::PointerType *BaseTy =
1625       cast<llvm::PointerType>(BaseValue->getType());
1626     unsigned AS = BaseTy->getAddressSpace();
1627     V = Builder.CreateBitCast(V,
1628                               llvm::PointerType::get(FieldTy, AS),
1629                               "tmp");
1630   }
1631   if (Field->getType()->isReferenceType())
1632     V = Builder.CreateLoad(V, "tmp");
1633
1634   unsigned Alignment = getContext().getDeclAlign(Field).getQuantity();
1635   LValue LV = MakeAddrLValue(V, Field->getType(), Alignment);
1636   LV.getQuals().addCVRQualifiers(CVRQualifiers);
1637
1638   // __weak attribute on a field is ignored.
1639   if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak)
1640     LV.getQuals().removeObjCGCAttr();
1641
1642   return LV;
1643 }
1644
1645 LValue
1646 CodeGenFunction::EmitLValueForFieldInitialization(llvm::Value *BaseValue,
1647                                                   const FieldDecl *Field,
1648                                                   unsigned CVRQualifiers) {
1649   QualType FieldType = Field->getType();
1650
1651   if (!FieldType->isReferenceType())
1652     return EmitLValueForField(BaseValue, Field, CVRQualifiers);
1653
1654   const CGRecordLayout &RL =
1655     CGM.getTypes().getCGRecordLayout(Field->getParent());
1656   unsigned idx = RL.getLLVMFieldNo(Field);
1657   llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp");
1658
1659   assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
1660
1661   unsigned Alignment = getContext().getDeclAlign(Field).getQuantity();
1662   return MakeAddrLValue(V, FieldType, Alignment);
1663 }
1664
1665 LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){
1666   llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral");
1667   const Expr *InitExpr = E->getInitializer();
1668   LValue Result = MakeAddrLValue(DeclPtr, E->getType());
1669
1670   EmitAnyExprToMem(InitExpr, DeclPtr, /*Volatile*/ false, /*Init*/ true);
1671
1672   return Result;
1673 }
1674
1675 LValue CodeGenFunction::
1676 EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) {
1677   if (!expr->isGLValue()) {
1678     // ?: here should be an aggregate.
1679     assert((hasAggregateLLVMType(expr->getType()) &&
1680             !expr->getType()->isAnyComplexType()) &&
1681            "Unexpected conditional operator!");
1682     return EmitAggExprToLValue(expr);
1683   }
1684
1685   const Expr *condExpr = expr->getCond();
1686
1687   if (int condValue = ConstantFoldsToSimpleInteger(condExpr)) {
1688     const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr();
1689     if (condValue == -1) std::swap(live, dead);
1690
1691     if (!ContainsLabel(dead))
1692       return EmitLValue(live);
1693   }
1694
1695   OpaqueValueMapping binding(*this, expr);
1696
1697   llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true");
1698   llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false");
1699   llvm::BasicBlock *contBlock = createBasicBlock("cond.end");
1700
1701   ConditionalEvaluation eval(*this);
1702   EmitBranchOnBoolExpr(condExpr, lhsBlock, rhsBlock);
1703
1704   // Any temporaries created here are conditional.
1705   EmitBlock(lhsBlock);
1706   eval.begin(*this);
1707   LValue lhs = EmitLValue(expr->getTrueExpr());
1708   eval.end(*this);
1709
1710   if (!lhs.isSimple())
1711     return EmitUnsupportedLValue(expr, "conditional operator");
1712
1713   lhsBlock = Builder.GetInsertBlock();
1714   Builder.CreateBr(contBlock);
1715
1716   // Any temporaries created here are conditional.
1717   EmitBlock(rhsBlock);
1718   eval.begin(*this);
1719   LValue rhs = EmitLValue(expr->getFalseExpr());
1720   eval.end(*this);
1721   if (!rhs.isSimple())
1722     return EmitUnsupportedLValue(expr, "conditional operator");
1723   rhsBlock = Builder.GetInsertBlock();
1724
1725   EmitBlock(contBlock);
1726
1727   llvm::PHINode *phi = Builder.CreatePHI(lhs.getAddress()->getType(),
1728                                          "cond-lvalue");
1729   phi->reserveOperandSpace(2);
1730   phi->addIncoming(lhs.getAddress(), lhsBlock);
1731   phi->addIncoming(rhs.getAddress(), rhsBlock);
1732   return MakeAddrLValue(phi, expr->getType());
1733 }
1734
1735 /// EmitCastLValue - Casts are never lvalues unless that cast is a dynamic_cast.
1736 /// If the cast is a dynamic_cast, we can have the usual lvalue result,
1737 /// otherwise if a cast is needed by the code generator in an lvalue context,
1738 /// then it must mean that we need the address of an aggregate in order to
1739 /// access one of its fields.  This can happen for all the reasons that casts
1740 /// are permitted with aggregate result, including noop aggregate casts, and
1741 /// cast from scalar to union.
1742 LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
1743   switch (E->getCastKind()) {
1744   case CK_ToVoid:
1745     return EmitUnsupportedLValue(E, "unexpected cast lvalue");
1746
1747   case CK_Dependent:
1748     llvm_unreachable("dependent cast kind in IR gen!");
1749
1750   case CK_GetObjCProperty: {
1751     LValue LV = EmitLValue(E->getSubExpr());
1752     assert(LV.isPropertyRef());
1753     RValue RV = EmitLoadOfPropertyRefLValue(LV);
1754
1755     // Property is an aggregate r-value.
1756     if (RV.isAggregate()) {
1757       return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
1758     }
1759
1760     // Implicit property returns an l-value.
1761     assert(RV.isScalar());
1762     return MakeAddrLValue(RV.getScalarVal(), E->getSubExpr()->getType());
1763   }
1764
1765   case CK_NoOp:
1766   case CK_LValueToRValue:
1767     if (!E->getSubExpr()->Classify(getContext()).isPRValue()
1768         || E->getType()->isRecordType())
1769       return EmitLValue(E->getSubExpr());
1770     // Fall through to synthesize a temporary.
1771
1772   case CK_BitCast:
1773   case CK_ArrayToPointerDecay:
1774   case CK_FunctionToPointerDecay:
1775   case CK_NullToMemberPointer:
1776   case CK_NullToPointer:
1777   case CK_IntegralToPointer:
1778   case CK_PointerToIntegral:
1779   case CK_PointerToBoolean:
1780   case CK_VectorSplat:
1781   case CK_IntegralCast:
1782   case CK_IntegralToBoolean:
1783   case CK_IntegralToFloating:
1784   case CK_FloatingToIntegral:
1785   case CK_FloatingToBoolean:
1786   case CK_FloatingCast:
1787   case CK_FloatingRealToComplex:
1788   case CK_FloatingComplexToReal:
1789   case CK_FloatingComplexToBoolean:
1790   case CK_FloatingComplexCast:
1791   case CK_FloatingComplexToIntegralComplex:
1792   case CK_IntegralRealToComplex:
1793   case CK_IntegralComplexToReal:
1794   case CK_IntegralComplexToBoolean:
1795   case CK_IntegralComplexCast:
1796   case CK_IntegralComplexToFloatingComplex:
1797   case CK_DerivedToBaseMemberPointer:
1798   case CK_BaseToDerivedMemberPointer:
1799   case CK_MemberPointerToBoolean:
1800   case CK_AnyPointerToBlockPointerCast: {
1801     // These casts only produce lvalues when we're binding a reference to a
1802     // temporary realized from a (converted) pure rvalue. Emit the expression
1803     // as a value, copy it into a temporary, and return an lvalue referring to
1804     // that temporary.
1805     llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp");
1806     EmitAnyExprToMem(E, V, false, false);
1807     return MakeAddrLValue(V, E->getType());
1808   }
1809
1810   case CK_Dynamic: {
1811     LValue LV = EmitLValue(E->getSubExpr());
1812     llvm::Value *V = LV.getAddress();
1813     const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E);
1814     return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType());
1815   }
1816
1817   case CK_ConstructorConversion:
1818   case CK_UserDefinedConversion:
1819   case CK_AnyPointerToObjCPointerCast:
1820     return EmitLValue(E->getSubExpr());
1821
1822   case CK_UncheckedDerivedToBase:
1823   case CK_DerivedToBase: {
1824     const RecordType *DerivedClassTy =
1825       E->getSubExpr()->getType()->getAs<RecordType>();
1826     CXXRecordDecl *DerivedClassDecl =
1827       cast<CXXRecordDecl>(DerivedClassTy->getDecl());
1828
1829     LValue LV = EmitLValue(E->getSubExpr());
1830     llvm::Value *This = LV.getAddress();
1831
1832     // Perform the derived-to-base conversion
1833     llvm::Value *Base =
1834       GetAddressOfBaseClass(This, DerivedClassDecl,
1835                             E->path_begin(), E->path_end(),
1836                             /*NullCheckValue=*/false);
1837
1838     return MakeAddrLValue(Base, E->getType());
1839   }
1840   case CK_ToUnion:
1841     return EmitAggExprToLValue(E);
1842   case CK_BaseToDerived: {
1843     const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>();
1844     CXXRecordDecl *DerivedClassDecl =
1845       cast<CXXRecordDecl>(DerivedClassTy->getDecl());
1846
1847     LValue LV = EmitLValue(E->getSubExpr());
1848
1849     // Perform the base-to-derived conversion
1850     llvm::Value *Derived =
1851       GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl,
1852                                E->path_begin(), E->path_end(),
1853                                /*NullCheckValue=*/false);
1854
1855     return MakeAddrLValue(Derived, E->getType());
1856   }
1857   case CK_LValueBitCast: {
1858     // This must be a reinterpret_cast (or c-style equivalent).
1859     const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E);
1860
1861     LValue LV = EmitLValue(E->getSubExpr());
1862     llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
1863                                            ConvertType(CE->getTypeAsWritten()));
1864     return MakeAddrLValue(V, E->getType());
1865   }
1866   case CK_ObjCObjectLValueCast: {
1867     LValue LV = EmitLValue(E->getSubExpr());
1868     QualType ToType = getContext().getLValueReferenceType(E->getType());
1869     llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
1870                                            ConvertType(ToType));
1871     return MakeAddrLValue(V, E->getType());
1872   }
1873   }
1874
1875   llvm_unreachable("Unhandled lvalue cast kind?");
1876 }
1877
1878 LValue CodeGenFunction::EmitNullInitializationLValue(
1879                                               const CXXScalarValueInitExpr *E) {
1880   QualType Ty = E->getType();
1881   LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty);
1882   EmitNullInitialization(LV.getAddress(), Ty);
1883   return LV;
1884 }
1885
1886 LValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) {
1887   assert(e->isGLValue() || e->getType()->isRecordType());
1888   return getOpaqueLValueMapping(e);
1889 }
1890
1891 //===--------------------------------------------------------------------===//
1892 //                             Expression Emission
1893 //===--------------------------------------------------------------------===//
1894
1895
1896 RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
1897                                      ReturnValueSlot ReturnValue) {
1898   // Builtins never have block type.
1899   if (E->getCallee()->getType()->isBlockPointerType())
1900     return EmitBlockCallExpr(E, ReturnValue);
1901
1902   if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E))
1903     return EmitCXXMemberCallExpr(CE, ReturnValue);
1904
1905   const Decl *TargetDecl = 0;
1906   if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) {
1907     if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) {
1908       TargetDecl = DRE->getDecl();
1909       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl))
1910         if (unsigned builtinID = FD->getBuiltinID())
1911           return EmitBuiltinExpr(FD, builtinID, E);
1912     }
1913   }
1914
1915   if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E))
1916     if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl))
1917       return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue);
1918
1919   if (isa<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) {
1920     // C++ [expr.pseudo]p1:
1921     //   The result shall only be used as the operand for the function call
1922     //   operator (), and the result of such a call has type void. The only
1923     //   effect is the evaluation of the postfix-expression before the dot or
1924     //   arrow.
1925     EmitScalarExpr(E->getCallee());
1926     return RValue::get(0);
1927   }
1928
1929   llvm::Value *Callee = EmitScalarExpr(E->getCallee());
1930   return EmitCall(E->getCallee()->getType(), Callee, ReturnValue,
1931                   E->arg_begin(), E->arg_end(), TargetDecl);
1932 }
1933
1934 LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
1935   // Comma expressions just emit their LHS then their RHS as an l-value.
1936   if (E->getOpcode() == BO_Comma) {
1937     EmitIgnoredExpr(E->getLHS());
1938     EnsureInsertPoint();
1939     return EmitLValue(E->getRHS());
1940   }
1941
1942   if (E->getOpcode() == BO_PtrMemD ||
1943       E->getOpcode() == BO_PtrMemI)
1944     return EmitPointerToDataMemberBinaryExpr(E);
1945
1946   assert(E->getOpcode() == BO_Assign && "unexpected binary l-value");
1947
1948   if (!hasAggregateLLVMType(E->getType())) {
1949     // __block variables need the RHS evaluated first.
1950     RValue RV = EmitAnyExpr(E->getRHS());
1951     LValue LV = EmitLValue(E->getLHS());
1952     EmitStoreThroughLValue(RV, LV, E->getType());
1953     return LV;
1954   }
1955
1956   if (E->getType()->isAnyComplexType())
1957     return EmitComplexAssignmentLValue(E);
1958
1959   return EmitAggExprToLValue(E);
1960 }
1961
1962 LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
1963   RValue RV = EmitCallExpr(E);
1964
1965   if (!RV.isScalar())
1966     return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
1967
1968   assert(E->getCallReturnType()->isReferenceType() &&
1969          "Can't have a scalar return unless the return type is a "
1970          "reference type!");
1971
1972   return MakeAddrLValue(RV.getScalarVal(), E->getType());
1973 }
1974
1975 LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
1976   // FIXME: This shouldn't require another copy.
1977   return EmitAggExprToLValue(E);
1978 }
1979
1980 LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
1981   assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor()
1982          && "binding l-value to type which needs a temporary");
1983   AggValueSlot Slot = CreateAggTemp(E->getType(), "tmp");
1984   EmitCXXConstructExpr(E, Slot);
1985   return MakeAddrLValue(Slot.getAddr(), E->getType());
1986 }
1987
1988 LValue
1989 CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) {
1990   return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType());
1991 }
1992
1993 LValue
1994 CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) {
1995   AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
1996   Slot.setLifetimeExternallyManaged();
1997   EmitAggExpr(E->getSubExpr(), Slot);
1998   EmitCXXTemporary(E->getTemporary(), Slot.getAddr());
1999   return MakeAddrLValue(Slot.getAddr(), E->getType());
2000 }
2001
2002 LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
2003   RValue RV = EmitObjCMessageExpr(E);
2004
2005   if (!RV.isScalar())
2006     return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
2007
2008   assert(E->getMethodDecl()->getResultType()->isReferenceType() &&
2009          "Can't have a scalar return unless the return type is a "
2010          "reference type!");
2011
2012   return MakeAddrLValue(RV.getScalarVal(), E->getType());
2013 }
2014
2015 LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) {
2016   llvm::Value *V =
2017     CGM.getObjCRuntime().GetSelector(Builder, E->getSelector(), true);
2018   return MakeAddrLValue(V, E->getType());
2019 }
2020
2021 llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface,
2022                                              const ObjCIvarDecl *Ivar) {
2023   return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar);
2024 }
2025
2026 LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
2027                                           llvm::Value *BaseValue,
2028                                           const ObjCIvarDecl *Ivar,
2029                                           unsigned CVRQualifiers) {
2030   return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue,
2031                                                    Ivar, CVRQualifiers);
2032 }
2033
2034 LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
2035   // FIXME: A lot of the code below could be shared with EmitMemberExpr.
2036   llvm::Value *BaseValue = 0;
2037   const Expr *BaseExpr = E->getBase();
2038   Qualifiers BaseQuals;
2039   QualType ObjectTy;
2040   if (E->isArrow()) {
2041     BaseValue = EmitScalarExpr(BaseExpr);
2042     ObjectTy = BaseExpr->getType()->getPointeeType();
2043     BaseQuals = ObjectTy.getQualifiers();
2044   } else {
2045     LValue BaseLV = EmitLValue(BaseExpr);
2046     // FIXME: this isn't right for bitfields.
2047     BaseValue = BaseLV.getAddress();
2048     ObjectTy = BaseExpr->getType();
2049     BaseQuals = ObjectTy.getQualifiers();
2050   }
2051
2052   LValue LV =
2053     EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(),
2054                       BaseQuals.getCVRQualifiers());
2055   setObjCGCLValueClass(getContext(), E, LV);
2056   return LV;
2057 }
2058
2059 LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
2060   // Can only get l-value for message expression returning aggregate type
2061   RValue RV = EmitAnyExprToTemp(E);
2062   return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
2063 }
2064
2065 RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee,
2066                                  ReturnValueSlot ReturnValue,
2067                                  CallExpr::const_arg_iterator ArgBeg,
2068                                  CallExpr::const_arg_iterator ArgEnd,
2069                                  const Decl *TargetDecl) {
2070   // Get the actual function type. The callee type will always be a pointer to
2071   // function type or a block pointer type.
2072   assert(CalleeType->isFunctionPointerType() &&
2073          "Call must have function pointer type!");
2074
2075   CalleeType = getContext().getCanonicalType(CalleeType);
2076
2077   const FunctionType *FnType
2078     = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType());
2079
2080   CallArgList Args;
2081   EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
2082
2083   return EmitCall(CGM.getTypes().getFunctionInfo(Args, FnType),
2084                   Callee, ReturnValue, Args, TargetDecl);
2085 }
2086
2087 LValue CodeGenFunction::
2088 EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
2089   llvm::Value *BaseV;
2090   if (E->getOpcode() == BO_PtrMemI)
2091     BaseV = EmitScalarExpr(E->getLHS());
2092   else
2093     BaseV = EmitLValue(E->getLHS()).getAddress();
2094
2095   llvm::Value *OffsetV = EmitScalarExpr(E->getRHS());
2096
2097   const MemberPointerType *MPT
2098     = E->getRHS()->getType()->getAs<MemberPointerType>();
2099
2100   llvm::Value *AddV =
2101     CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT);
2102
2103   return MakeAddrLValue(AddV, MPT->getPointeeType());
2104 }