contrib/llvm/tools/clang/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 "CGDebugInfo.h"
  19 #include "CGRecordLayout.h"
  20 #include "CGObjCRuntime.h"
  21 #include "TargetInfo.h"
  22 #include "clang/AST/ASTContext.h"
  23 #include "clang/AST/DeclObjC.h"
  24 #include "clang/Frontend/CodeGenOptions.h"
  25 #include "llvm/Intrinsics.h"
  26 #include "llvm/LLVMContext.h"
  27 #include "llvm/Support/MDBuilder.h"
  28 #include "llvm/Target/TargetData.h"
  29 using namespace clang;
  30 using namespace CodeGen;
  31
  32 //===--------------------------------------------------------------------===//
  33 //                        Miscellaneous Helper Methods
  34 //===--------------------------------------------------------------------===//
  35
  36 llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) {
  37   unsigned addressSpace =
  38     cast<llvm::PointerType>(value->getType())->getAddressSpace();
  39
  40   llvm::PointerType *destType = Int8PtrTy;
  41   if (addressSpace)
  42     destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace);
  43
  44   if (value->getType() == destType) return value;
  45   return Builder.CreateBitCast(value, destType);
  46 }
  47
  48 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
  49 /// block.
  50 llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty,
  51                                                     const Twine &Name) {
  52   if (!Builder.isNamePreserving())
  53     return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt);
  54   return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt);
  55 }
  56
  57 void CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var,
  58                                      llvm::Value *Init) {
  59   llvm::StoreInst *Store = new llvm::StoreInst(Init, Var);
  60   llvm::BasicBlock *Block = AllocaInsertPt->getParent();
  61   Block->getInstList().insertAfter(&*AllocaInsertPt, Store);
  62 }
  63
  64 llvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty,
  65                                                 const Twine &Name) {
  66   llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name);
  67   // FIXME: Should we prefer the preferred type alignment here?
  68   CharUnits Align = getContext().getTypeAlignInChars(Ty);
  69   Alloc->setAlignment(Align.getQuantity());
  70   return Alloc;
  71 }
  72
  73 llvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty,
  74                                                  const Twine &Name) {
  75   llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name);
  76   // FIXME: Should we prefer the preferred type alignment here?
  77   CharUnits Align = getContext().getTypeAlignInChars(Ty);
  78   Alloc->setAlignment(Align.getQuantity());
  79   return Alloc;
  80 }
  81
  82 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
  83 /// expression and compare the result against zero, returning an Int1Ty value.
  84 llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
  85   if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) {
  86     llvm::Value *MemPtr = EmitScalarExpr(E);
  87     return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT);
  88   }
  89
  90   QualType BoolTy = getContext().BoolTy;
  91   if (!E->getType()->isAnyComplexType())
  92     return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy);
  93
  94   return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy);
  95 }
  96
  97 /// EmitIgnoredExpr - Emit code to compute the specified expression,
  98 /// ignoring the result.
  99 void CodeGenFunction::EmitIgnoredExpr(const Expr *E) {
 100   if (E->isRValue())
 101     return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true);
 102
 103   // Just emit it as an l-value and drop the result.
 104   EmitLValue(E);
 105 }
 106
 107 /// EmitAnyExpr - Emit code to compute the specified expression which
 108 /// can have any type.  The result is returned as an RValue struct.
 109 /// If this is an aggregate expression, AggSlot indicates where the
 110 /// result should be returned.
 111 RValue CodeGenFunction::EmitAnyExpr(const Expr *E, AggValueSlot AggSlot,
 112                                     bool IgnoreResult) {
 113   if (!hasAggregateLLVMType(E->getType()))
 114     return RValue::get(EmitScalarExpr(E, IgnoreResult));
 115   else if (E->getType()->isAnyComplexType())
 116     return RValue::getComplex(EmitComplexExpr(E, IgnoreResult, IgnoreResult));
 117
 118   EmitAggExpr(E, AggSlot, IgnoreResult);
 119   return AggSlot.asRValue();
 120 }
 121
 122 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
 123 /// always be accessible even if no aggregate location is provided.
 124 RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) {
 125   AggValueSlot AggSlot = AggValueSlot::ignored();
 126
 127   if (hasAggregateLLVMType(E->getType()) &&
 128       !E->getType()->isAnyComplexType())
 129     AggSlot = CreateAggTemp(E->getType(), "agg.tmp");
 130   return EmitAnyExpr(E, AggSlot);
 131 }
 132
 133 /// EmitAnyExprToMem - Evaluate an expression into a given memory
 134 /// location.
 135 void CodeGenFunction::EmitAnyExprToMem(const Expr *E,
 136                                        llvm::Value *Location,
 137                                        Qualifiers Quals,
 138                                        bool IsInit) {
 139   // FIXME: This function should take an LValue as an argument.
 140   if (E->getType()->isAnyComplexType()) {
 141     EmitComplexExprIntoAddr(E, Location, Quals.hasVolatile());
 142   } else if (hasAggregateLLVMType(E->getType())) {
 143     CharUnits Alignment = getContext().getTypeAlignInChars(E->getType());
 144     EmitAggExpr(E, AggValueSlot::forAddr(Location, Alignment, Quals,
 145                                          AggValueSlot::IsDestructed_t(IsInit),
 146                                          AggValueSlot::DoesNotNeedGCBarriers,
 147                                          AggValueSlot::IsAliased_t(!IsInit)));
 148   } else {
 149     RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false));
 150     LValue LV = MakeAddrLValue(Location, E->getType());
 151     EmitStoreThroughLValue(RV, LV);
 152   }
 153 }
 154
 155 namespace {
 156 /// \brief An adjustment to be made to the temporary created when emitting a
 157 /// reference binding, which accesses a particular subobject of that temporary.
 158   struct SubobjectAdjustment {
 159     enum { DerivedToBaseAdjustment, FieldAdjustment } Kind;
 160
 161     union {
 162       struct {
 163         const CastExpr *BasePath;
 164         const CXXRecordDecl *DerivedClass;
 165       } DerivedToBase;
 166
 167       FieldDecl *Field;
 168     };
 169
 170     SubobjectAdjustment(const CastExpr *BasePath,
 171                         const CXXRecordDecl *DerivedClass)
 172       : Kind(DerivedToBaseAdjustment) {
 173       DerivedToBase.BasePath = BasePath;
 174       DerivedToBase.DerivedClass = DerivedClass;
 175     }
 176
 177     SubobjectAdjustment(FieldDecl *Field)
 178       : Kind(FieldAdjustment) {
 179       this->Field = Field;
 180     }
 181   };
 182 }
 183
 184 static llvm::Value *
 185 CreateReferenceTemporary(CodeGenFunction &CGF, QualType Type,
 186                          const NamedDecl *InitializedDecl) {
 187   if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
 188     if (VD->hasGlobalStorage()) {
 189       SmallString<256> Name;
 190       llvm::raw_svector_ostream Out(Name);
 191       CGF.CGM.getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Out);
 192       Out.flush();
 193
 194       llvm::Type *RefTempTy = CGF.ConvertTypeForMem(Type);
 195
 196       // Create the reference temporary.
 197       llvm::GlobalValue *RefTemp =
 198         new llvm::GlobalVariable(CGF.CGM.getModule(),
 199                                  RefTempTy, /*isConstant=*/false,
 200                                  llvm::GlobalValue::InternalLinkage,
 201                                  llvm::Constant::getNullValue(RefTempTy),
 202                                  Name.str());
 203       return RefTemp;
 204     }
 205   }
 206
 207   return CGF.CreateMemTemp(Type, "ref.tmp");
 208 }
 209
 210 static llvm::Value *
 211 EmitExprForReferenceBinding(CodeGenFunction &CGF, const Expr *E,
 212                             llvm::Value *&ReferenceTemporary,
 213                             const CXXDestructorDecl *&ReferenceTemporaryDtor,
 214                             QualType &ObjCARCReferenceLifetimeType,
 215                             const NamedDecl *InitializedDecl) {
 216   // Look through single-element init lists that claim to be lvalues. They're
 217   // just syntactic wrappers in this case.
 218   if (const InitListExpr *ILE = dyn_cast<InitListExpr>(E)) {
 219     if (ILE->getNumInits() == 1 && ILE->isGLValue())
 220       E = ILE->getInit(0);
 221   }
 222
 223   // Look through expressions for materialized temporaries (for now).
 224   if (const MaterializeTemporaryExpr *M
 225                                       = dyn_cast<MaterializeTemporaryExpr>(E)) {
 226     // Objective-C++ ARC:
 227     //   If we are binding a reference to a temporary that has ownership, we
 228     //   need to perform retain/release operations on the temporary.
 229     if (CGF.getContext().getLangOpts().ObjCAutoRefCount &&
 230         E->getType()->isObjCLifetimeType() &&
 231         (E->getType().getObjCLifetime() == Qualifiers::OCL_Strong ||
 232          E->getType().getObjCLifetime() == Qualifiers::OCL_Weak ||
 233          E->getType().getObjCLifetime() == Qualifiers::OCL_Autoreleasing))
 234       ObjCARCReferenceLifetimeType = E->getType();
 235
 236     E = M->GetTemporaryExpr();
 237   }
 238
 239   if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E))
 240     E = DAE->getExpr();
 241
 242   if (const ExprWithCleanups *EWC = dyn_cast<ExprWithCleanups>(E)) {
 243     CGF.enterFullExpression(EWC);
 244     CodeGenFunction::RunCleanupsScope Scope(CGF);
 245
 246     return EmitExprForReferenceBinding(CGF, EWC->getSubExpr(),
 247                                        ReferenceTemporary,
 248                                        ReferenceTemporaryDtor,
 249                                        ObjCARCReferenceLifetimeType,
 250                                        InitializedDecl);
 251   }
 252
 253   RValue RV;
 254   if (E->isGLValue()) {
 255     // Emit the expression as an lvalue.
 256     LValue LV = CGF.EmitLValue(E);
 257
 258     if (LV.isSimple())
 259       return LV.getAddress();
 260
 261     // We have to load the lvalue.
 262     RV = CGF.EmitLoadOfLValue(LV);
 263   } else {
 264     if (!ObjCARCReferenceLifetimeType.isNull()) {
 265       ReferenceTemporary = CreateReferenceTemporary(CGF,
 266                                                   ObjCARCReferenceLifetimeType,
 267                                                     InitializedDecl);
 268
 269
 270       LValue RefTempDst = CGF.MakeAddrLValue(ReferenceTemporary,
 271                                              ObjCARCReferenceLifetimeType);
 272
 273       CGF.EmitScalarInit(E, dyn_cast_or_null<ValueDecl>(InitializedDecl),
 274                          RefTempDst, false);
 275
 276       bool ExtendsLifeOfTemporary = false;
 277       if (const VarDecl *Var = dyn_cast_or_null<VarDecl>(InitializedDecl)) {
 278         if (Var->extendsLifetimeOfTemporary())
 279           ExtendsLifeOfTemporary = true;
 280       } else if (InitializedDecl && isa<FieldDecl>(InitializedDecl)) {
 281         ExtendsLifeOfTemporary = true;
 282       }
 283
 284       if (!ExtendsLifeOfTemporary) {
 285         // Since the lifetime of this temporary isn't going to be extended,
 286         // we need to clean it up ourselves at the end of the full expression.
 287         switch (ObjCARCReferenceLifetimeType.getObjCLifetime()) {
 288         case Qualifiers::OCL_None:
 289         case Qualifiers::OCL_ExplicitNone:
 290         case Qualifiers::OCL_Autoreleasing:
 291           break;
 292
 293         case Qualifiers::OCL_Strong: {
 294           assert(!ObjCARCReferenceLifetimeType->isArrayType());
 295           CleanupKind cleanupKind = CGF.getARCCleanupKind();
 296           CGF.pushDestroy(cleanupKind,
 297                           ReferenceTemporary,
 298                           ObjCARCReferenceLifetimeType,
 299                           CodeGenFunction::destroyARCStrongImprecise,
 300                           cleanupKind & EHCleanup);
 301           break;
 302         }
 303
 304         case Qualifiers::OCL_Weak:
 305           assert(!ObjCARCReferenceLifetimeType->isArrayType());
 306           CGF.pushDestroy(NormalAndEHCleanup,
 307                           ReferenceTemporary,
 308                           ObjCARCReferenceLifetimeType,
 309                           CodeGenFunction::destroyARCWeak,
 310                           /*useEHCleanupForArray*/ true);
 311           break;
 312         }
 313
 314         ObjCARCReferenceLifetimeType = QualType();
 315       }
 316
 317       return ReferenceTemporary;
 318     }
 319
 320     SmallVector<SubobjectAdjustment, 2> Adjustments;
 321     while (true) {
 322       E = E->IgnoreParens();
 323
 324       if (const CastExpr *CE = dyn_cast<CastExpr>(E)) {
 325         if ((CE->getCastKind() == CK_DerivedToBase ||
 326              CE->getCastKind() == CK_UncheckedDerivedToBase) &&
 327             E->getType()->isRecordType()) {
 328           E = CE->getSubExpr();
 329           CXXRecordDecl *Derived
 330             = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl());
 331           Adjustments.push_back(SubobjectAdjustment(CE, Derived));
 332           continue;
 333         }
 334
 335         if (CE->getCastKind() == CK_NoOp) {
 336           E = CE->getSubExpr();
 337           continue;
 338         }
 339       } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) {
 340         if (!ME->isArrow() && ME->getBase()->isRValue()) {
 341           assert(ME->getBase()->getType()->isRecordType());
 342           if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) {
 343             E = ME->getBase();
 344             Adjustments.push_back(SubobjectAdjustment(Field));
 345             continue;
 346           }
 347         }
 348       }
 349
 350       if (const OpaqueValueExpr *opaque = dyn_cast<OpaqueValueExpr>(E))
 351         if (opaque->getType()->isRecordType())
 352           return CGF.EmitOpaqueValueLValue(opaque).getAddress();
 353
 354       // Nothing changed.
 355       break;
 356     }
 357
 358     // Create a reference temporary if necessary.
 359     AggValueSlot AggSlot = AggValueSlot::ignored();
 360     if (CGF.hasAggregateLLVMType(E->getType()) &&
 361         !E->getType()->isAnyComplexType()) {
 362       ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
 363                                                     InitializedDecl);
 364       CharUnits Alignment = CGF.getContext().getTypeAlignInChars(E->getType());
 365       AggValueSlot::IsDestructed_t isDestructed
 366         = AggValueSlot::IsDestructed_t(InitializedDecl != 0);
 367       AggSlot = AggValueSlot::forAddr(ReferenceTemporary, Alignment,
 368                                       Qualifiers(), isDestructed,
 369                                       AggValueSlot::DoesNotNeedGCBarriers,
 370                                       AggValueSlot::IsNotAliased);
 371     }
 372
 373     if (InitializedDecl) {
 374       // Get the destructor for the reference temporary.
 375       if (const RecordType *RT = E->getType()->getAs<RecordType>()) {
 376         CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RT->getDecl());
 377         if (!ClassDecl->hasTrivialDestructor())
 378           ReferenceTemporaryDtor = ClassDecl->getDestructor();
 379       }
 380     }
 381
 382     RV = CGF.EmitAnyExpr(E, AggSlot);
 383
 384     // Check if need to perform derived-to-base casts and/or field accesses, to
 385     // get from the temporary object we created (and, potentially, for which we
 386     // extended the lifetime) to the subobject we're binding the reference to.
 387     if (!Adjustments.empty()) {
 388       llvm::Value *Object = RV.getAggregateAddr();
 389       for (unsigned I = Adjustments.size(); I != 0; --I) {
 390         SubobjectAdjustment &Adjustment = Adjustments[I-1];
 391         switch (Adjustment.Kind) {
 392         case SubobjectAdjustment::DerivedToBaseAdjustment:
 393           Object =
 394               CGF.GetAddressOfBaseClass(Object,
 395                                         Adjustment.DerivedToBase.DerivedClass,
 396                               Adjustment.DerivedToBase.BasePath->path_begin(),
 397                               Adjustment.DerivedToBase.BasePath->path_end(),
 398                                         /*NullCheckValue=*/false);
 399           break;
 400
 401         case SubobjectAdjustment::FieldAdjustment: {
 402           LValue LV = CGF.MakeAddrLValue(Object, E->getType());
 403           LV = CGF.EmitLValueForField(LV, Adjustment.Field);
 404           if (LV.isSimple()) {
 405             Object = LV.getAddress();
 406             break;
 407           }
 408
 409           // For non-simple lvalues, we actually have to create a copy of
 410           // the object we're binding to.
 411           QualType T = Adjustment.Field->getType().getNonReferenceType()
 412                                                   .getUnqualifiedType();
 413           Object = CreateReferenceTemporary(CGF, T, InitializedDecl);
 414           LValue TempLV = CGF.MakeAddrLValue(Object,
 415                                              Adjustment.Field->getType());
 416           CGF.EmitStoreThroughLValue(CGF.EmitLoadOfLValue(LV), TempLV);
 417           break;
 418         }
 419
 420         }
 421       }
 422
 423       return Object;
 424     }
 425   }
 426
 427   if (RV.isAggregate())
 428     return RV.getAggregateAddr();
 429
 430   // Create a temporary variable that we can bind the reference to.
 431   ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(),
 432                                                 InitializedDecl);
 433
 434
 435   unsigned Alignment =
 436     CGF.getContext().getTypeAlignInChars(E->getType()).getQuantity();
 437   if (RV.isScalar())
 438     CGF.EmitStoreOfScalar(RV.getScalarVal(), ReferenceTemporary,
 439                           /*Volatile=*/false, Alignment, E->getType());
 440   else
 441     CGF.StoreComplexToAddr(RV.getComplexVal(), ReferenceTemporary,
 442                            /*Volatile=*/false);
 443   return ReferenceTemporary;
 444 }
 445
 446 RValue
 447 CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E,
 448                                             const NamedDecl *InitializedDecl) {
 449   llvm::Value *ReferenceTemporary = 0;
 450   const CXXDestructorDecl *ReferenceTemporaryDtor = 0;
 451   QualType ObjCARCReferenceLifetimeType;
 452   llvm::Value *Value = EmitExprForReferenceBinding(*this, E, ReferenceTemporary,
 453                                                    ReferenceTemporaryDtor,
 454                                                    ObjCARCReferenceLifetimeType,
 455                                                    InitializedDecl);
 456   if (!ReferenceTemporaryDtor && ObjCARCReferenceLifetimeType.isNull())
 457     return RValue::get(Value);
 458
 459   // Make sure to call the destructor for the reference temporary.
 460   const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl);
 461   if (VD && VD->hasGlobalStorage()) {
 462     if (ReferenceTemporaryDtor) {
 463       llvm::Constant *DtorFn =
 464         CGM.GetAddrOfCXXDestructor(ReferenceTemporaryDtor, Dtor_Complete);
 465       EmitCXXGlobalDtorRegistration(DtorFn,
 466                                     cast<llvm::Constant>(ReferenceTemporary));
 467     } else {
 468       assert(!ObjCARCReferenceLifetimeType.isNull());
 469       // Note: We intentionally do not register a global "destructor" to
 470       // release the object.
 471     }
 472
 473     return RValue::get(Value);
 474   }
 475
 476   if (ReferenceTemporaryDtor)
 477     PushDestructorCleanup(ReferenceTemporaryDtor, ReferenceTemporary);
 478   else {
 479     switch (ObjCARCReferenceLifetimeType.getObjCLifetime()) {
 480     case Qualifiers::OCL_None:
 481       llvm_unreachable(
 482                       "Not a reference temporary that needs to be deallocated");
 483     case Qualifiers::OCL_ExplicitNone:
 484     case Qualifiers::OCL_Autoreleasing:
 485       // Nothing to do.
 486       break;
 487
 488     case Qualifiers::OCL_Strong: {
 489       bool precise = VD && VD->hasAttr<ObjCPreciseLifetimeAttr>();
 490       CleanupKind cleanupKind = getARCCleanupKind();
 491       pushDestroy(cleanupKind, ReferenceTemporary, ObjCARCReferenceLifetimeType,
 492                   precise ? destroyARCStrongPrecise : destroyARCStrongImprecise,
 493                   cleanupKind & EHCleanup);
 494       break;
 495     }
 496
 497     case Qualifiers::OCL_Weak: {
 498       // __weak objects always get EH cleanups; otherwise, exceptions
 499       // could cause really nasty crashes instead of mere leaks.
 500       pushDestroy(NormalAndEHCleanup, ReferenceTemporary,
 501                   ObjCARCReferenceLifetimeType, destroyARCWeak, true);
 502       break;
 503     }
 504     }
 505   }
 506
 507   return RValue::get(Value);
 508 }
 509
 510
 511 /// getAccessedFieldNo - Given an encoded value and a result number, return the
 512 /// input field number being accessed.
 513 unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx,
 514                                              const llvm::Constant *Elts) {
 515   return cast<llvm::ConstantInt>(Elts->getAggregateElement(Idx))
 516       ->getZExtValue();
 517 }
 518
 519 void CodeGenFunction::EmitCheck(llvm::Value *Address, unsigned Size) {
 520   if (!CatchUndefined)
 521     return;
 522
 523   // This needs to be to the standard address space.
 524   Address = Builder.CreateBitCast(Address, Int8PtrTy);
 525
 526   llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, IntPtrTy);
 527
 528   // In time, people may want to control this and use a 1 here.
 529   llvm::Value *Arg = Builder.getFalse();
 530   llvm::Value *C = Builder.CreateCall2(F, Address, Arg);
 531   llvm::BasicBlock *Cont = createBasicBlock();
 532   llvm::BasicBlock *Check = createBasicBlock();
 533   llvm::Value *NegativeOne = llvm::ConstantInt::get(IntPtrTy, -1ULL);
 534   Builder.CreateCondBr(Builder.CreateICmpEQ(C, NegativeOne), Cont, Check);
 535
 536   EmitBlock(Check);
 537   Builder.CreateCondBr(Builder.CreateICmpUGE(C,
 538                                         llvm::ConstantInt::get(IntPtrTy, Size)),
 539                        Cont, getTrapBB());
 540   EmitBlock(Cont);
 541 }
 542
 543
 544 CodeGenFunction::ComplexPairTy CodeGenFunction::
 545 EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV,
 546                          bool isInc, bool isPre) {
 547   ComplexPairTy InVal = LoadComplexFromAddr(LV.getAddress(),
 548                                             LV.isVolatileQualified());
 549
 550   llvm::Value *NextVal;
 551   if (isa<llvm::IntegerType>(InVal.first->getType())) {
 552     uint64_t AmountVal = isInc ? 1 : -1;
 553     NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true);
 554
 555     // Add the inc/dec to the real part.
 556     NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
 557   } else {
 558     QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType();
 559     llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1);
 560     if (!isInc)
 561       FVal.changeSign();
 562     NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal);
 563
 564     // Add the inc/dec to the real part.
 565     NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec");
 566   }
 567
 568   ComplexPairTy IncVal(NextVal, InVal.second);
 569
 570   // Store the updated result through the lvalue.
 571   StoreComplexToAddr(IncVal, LV.getAddress(), LV.isVolatileQualified());
 572
 573   // If this is a postinc, return the value read from memory, otherwise use the
 574   // updated value.
 575   return isPre ? IncVal : InVal;
 576 }
 577
 578
 579 //===----------------------------------------------------------------------===//
 580 //                         LValue Expression Emission
 581 //===----------------------------------------------------------------------===//
 582
 583 RValue CodeGenFunction::GetUndefRValue(QualType Ty) {
 584   if (Ty->isVoidType())
 585     return RValue::get(0);
 586
 587   if (const ComplexType *CTy = Ty->getAs<ComplexType>()) {
 588     llvm::Type *EltTy = ConvertType(CTy->getElementType());
 589     llvm::Value *U = llvm::UndefValue::get(EltTy);
 590     return RValue::getComplex(std::make_pair(U, U));
 591   }
 592
 593   // If this is a use of an undefined aggregate type, the aggregate must have an
 594   // identifiable address.  Just because the contents of the value are undefined
 595   // doesn't mean that the address can't be taken and compared.
 596   if (hasAggregateLLVMType(Ty)) {
 597     llvm::Value *DestPtr = CreateMemTemp(Ty, "undef.agg.tmp");
 598     return RValue::getAggregate(DestPtr);
 599   }
 600
 601   return RValue::get(llvm::UndefValue::get(ConvertType(Ty)));
 602 }
 603
 604 RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
 605                                               const char *Name) {
 606   ErrorUnsupported(E, Name);
 607   return GetUndefRValue(E->getType());
 608 }
 609
 610 LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E,
 611                                               const char *Name) {
 612   ErrorUnsupported(E, Name);
 613   llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
 614   return MakeAddrLValue(llvm::UndefValue::get(Ty), E->getType());
 615 }
 616
 617 LValue CodeGenFunction::EmitCheckedLValue(const Expr *E) {
 618   LValue LV = EmitLValue(E);
 619   if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple())
 620     EmitCheck(LV.getAddress(),
 621               getContext().getTypeSizeInChars(E->getType()).getQuantity());
 622   return LV;
 623 }
 624
 625 /// EmitLValue - Emit code to compute a designator that specifies the location
 626 /// of the expression.
 627 ///
 628 /// This can return one of two things: a simple address or a bitfield reference.
 629 /// In either case, the LLVM Value* in the LValue structure is guaranteed to be
 630 /// an LLVM pointer type.
 631 ///
 632 /// If this returns a bitfield reference, nothing about the pointee type of the
 633 /// LLVM value is known: For example, it may not be a pointer to an integer.
 634 ///
 635 /// If this returns a normal address, and if the lvalue's C type is fixed size,
 636 /// this method guarantees that the returned pointer type will point to an LLVM
 637 /// type of the same size of the lvalue's type.  If the lvalue has a variable
 638 /// length type, this is not possible.
 639 ///
 640 LValue CodeGenFunction::EmitLValue(const Expr *E) {
 641   switch (E->getStmtClass()) {
 642   default: return EmitUnsupportedLValue(E, "l-value expression");
 643
 644   case Expr::ObjCPropertyRefExprClass:
 645     llvm_unreachable("cannot emit a property reference directly");
 646
 647   case Expr::ObjCSelectorExprClass:
 648   return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E));
 649   case Expr::ObjCIsaExprClass:
 650     return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E));
 651   case Expr::BinaryOperatorClass:
 652     return EmitBinaryOperatorLValue(cast<BinaryOperator>(E));
 653   case Expr::CompoundAssignOperatorClass:
 654     if (!E->getType()->isAnyComplexType())
 655       return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
 656     return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E));
 657   case Expr::CallExprClass:
 658   case Expr::CXXMemberCallExprClass:
 659   case Expr::CXXOperatorCallExprClass:
 660   case Expr::UserDefinedLiteralClass:
 661     return EmitCallExprLValue(cast<CallExpr>(E));
 662   case Expr::VAArgExprClass:
 663     return EmitVAArgExprLValue(cast<VAArgExpr>(E));
 664   case Expr::DeclRefExprClass:
 665     return EmitDeclRefLValue(cast<DeclRefExpr>(E));
 666   case Expr::ParenExprClass:
 667     return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
 668   case Expr::GenericSelectionExprClass:
 669     return EmitLValue(cast<GenericSelectionExpr>(E)->getResultExpr());
 670   case Expr::PredefinedExprClass:
 671     return EmitPredefinedLValue(cast<PredefinedExpr>(E));
 672   case Expr::StringLiteralClass:
 673     return EmitStringLiteralLValue(cast<StringLiteral>(E));
 674   case Expr::ObjCEncodeExprClass:
 675     return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E));
 676   case Expr::PseudoObjectExprClass:
 677     return EmitPseudoObjectLValue(cast<PseudoObjectExpr>(E));
 678   case Expr::InitListExprClass:
 679     assert(cast<InitListExpr>(E)->getNumInits() == 1 &&
 680            "Only single-element init list can be lvalue.");
 681     return EmitLValue(cast<InitListExpr>(E)->getInit(0));
 682
 683   case Expr::CXXTemporaryObjectExprClass:
 684   case Expr::CXXConstructExprClass:
 685     return EmitCXXConstructLValue(cast<CXXConstructExpr>(E));
 686   case Expr::CXXBindTemporaryExprClass:
 687     return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E));
 688   case Expr::LambdaExprClass:
 689     return EmitLambdaLValue(cast<LambdaExpr>(E));
 690
 691   case Expr::ExprWithCleanupsClass: {
 692     const ExprWithCleanups *cleanups = cast<ExprWithCleanups>(E);
 693     enterFullExpression(cleanups);
 694     RunCleanupsScope Scope(*this);
 695     return EmitLValue(cleanups->getSubExpr());
 696   }
 697
 698   case Expr::CXXScalarValueInitExprClass:
 699     return EmitNullInitializationLValue(cast<CXXScalarValueInitExpr>(E));
 700   case Expr::CXXDefaultArgExprClass:
 701     return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr());
 702   case Expr::CXXTypeidExprClass:
 703     return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
 704
 705   case Expr::ObjCMessageExprClass:
 706     return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E));
 707   case Expr::ObjCIvarRefExprClass:
 708     return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E));
 709   case Expr::StmtExprClass:
 710     return EmitStmtExprLValue(cast<StmtExpr>(E));
 711   case Expr::UnaryOperatorClass:
 712     return EmitUnaryOpLValue(cast<UnaryOperator>(E));
 713   case Expr::ArraySubscriptExprClass:
 714     return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E));
 715   case Expr::ExtVectorElementExprClass:
 716     return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E));
 717   case Expr::MemberExprClass:
 718     return EmitMemberExpr(cast<MemberExpr>(E));
 719   case Expr::CompoundLiteralExprClass:
 720     return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
 721   case Expr::ConditionalOperatorClass:
 722     return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E));
 723   case Expr::BinaryConditionalOperatorClass:
 724     return EmitConditionalOperatorLValue(cast<BinaryConditionalOperator>(E));
 725   case Expr::ChooseExprClass:
 726     return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext()));
 727   case Expr::OpaqueValueExprClass:
 728     return EmitOpaqueValueLValue(cast<OpaqueValueExpr>(E));
 729   case Expr::SubstNonTypeTemplateParmExprClass:
 730     return EmitLValue(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
 731   case Expr::ImplicitCastExprClass:
 732   case Expr::CStyleCastExprClass:
 733   case Expr::CXXFunctionalCastExprClass:
 734   case Expr::CXXStaticCastExprClass:
 735   case Expr::CXXDynamicCastExprClass:
 736   case Expr::CXXReinterpretCastExprClass:
 737   case Expr::CXXConstCastExprClass:
 738   case Expr::ObjCBridgedCastExprClass:
 739     return EmitCastLValue(cast<CastExpr>(E));
 740
 741   case Expr::MaterializeTemporaryExprClass:
 742     return EmitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(E));
 743   }
 744 }
 745
 746 /// Given an object of the given canonical type, can we safely copy a
 747 /// value out of it based on its initializer?
 748 static bool isConstantEmittableObjectType(QualType type) {
 749   assert(type.isCanonical());
 750   assert(!type->isReferenceType());
 751
 752   // Must be const-qualified but non-volatile.
 753   Qualifiers qs = type.getLocalQualifiers();
 754   if (!qs.hasConst() || qs.hasVolatile()) return false;
 755
 756   // Otherwise, all object types satisfy this except C++ classes with
 757   // mutable subobjects or non-trivial copy/destroy behavior.
 758   if (const RecordType *RT = dyn_cast<RecordType>(type))
 759     if (const CXXRecordDecl *RD = dyn_cast<CXXRecordDecl>(RT->getDecl()))
 760       if (RD->hasMutableFields() || !RD->isTrivial())
 761         return false;
 762
 763   return true;
 764 }
 765
 766 /// Can we constant-emit a load of a reference to a variable of the
 767 /// given type?  This is different from predicates like
 768 /// Decl::isUsableInConstantExpressions because we do want it to apply
 769 /// in situations that don't necessarily satisfy the language's rules
 770 /// for this (e.g. C++'s ODR-use rules).  For example, we want to able
 771 /// to do this with const float variables even if those variables
 772 /// aren't marked 'constexpr'.
 773 enum ConstantEmissionKind {
 774   CEK_None,
 775   CEK_AsReferenceOnly,
 776   CEK_AsValueOrReference,
 777   CEK_AsValueOnly
 778 };
 779 static ConstantEmissionKind checkVarTypeForConstantEmission(QualType type) {
 780   type = type.getCanonicalType();
 781   if (const ReferenceType *ref = dyn_cast<ReferenceType>(type)) {
 782     if (isConstantEmittableObjectType(ref->getPointeeType()))
 783       return CEK_AsValueOrReference;
 784     return CEK_AsReferenceOnly;
 785   }
 786   if (isConstantEmittableObjectType(type))
 787     return CEK_AsValueOnly;
 788   return CEK_None;
 789 }
 790
 791 /// Try to emit a reference to the given value without producing it as
 792 /// an l-value.  This is actually more than an optimization: we can't
 793 /// produce an l-value for variables that we never actually captured
 794 /// in a block or lambda, which means const int variables or constexpr
 795 /// literals or similar.
 796 CodeGenFunction::ConstantEmission
 797 CodeGenFunction::tryEmitAsConstant(DeclRefExpr *refExpr) {
 798   ValueDecl *value = refExpr->getDecl();
 799
 800   // The value needs to be an enum constant or a constant variable.
 801   ConstantEmissionKind CEK;
 802   if (isa<ParmVarDecl>(value)) {
 803     CEK = CEK_None;
 804   } else if (VarDecl *var = dyn_cast<VarDecl>(value)) {
 805     CEK = checkVarTypeForConstantEmission(var->getType());
 806   } else if (isa<EnumConstantDecl>(value)) {
 807     CEK = CEK_AsValueOnly;
 808   } else {
 809     CEK = CEK_None;
 810   }
 811   if (CEK == CEK_None) return ConstantEmission();
 812
 813   Expr::EvalResult result;
 814   bool resultIsReference;
 815   QualType resultType;
 816
 817   // It's best to evaluate all the way as an r-value if that's permitted.
 818   if (CEK != CEK_AsReferenceOnly &&
 819       refExpr->EvaluateAsRValue(result, getContext())) {
 820     resultIsReference = false;
 821     resultType = refExpr->getType();
 822
 823   // Otherwise, try to evaluate as an l-value.
 824   } else if (CEK != CEK_AsValueOnly &&
 825              refExpr->EvaluateAsLValue(result, getContext())) {
 826     resultIsReference = true;
 827     resultType = value->getType();
 828
 829   // Failure.
 830   } else {
 831     return ConstantEmission();
 832   }
 833
 834   // In any case, if the initializer has side-effects, abandon ship.
 835   if (result.HasSideEffects)
 836     return ConstantEmission();
 837
 838   // Emit as a constant.
 839   llvm::Constant *C = CGM.EmitConstantValue(result.Val, resultType, this);
 840
 841   // Make sure we emit a debug reference to the global variable.
 842   // This should probably fire even for
 843   if (isa<VarDecl>(value)) {
 844     if (!getContext().DeclMustBeEmitted(cast<VarDecl>(value)))
 845       EmitDeclRefExprDbgValue(refExpr, C);
 846   } else {
 847     assert(isa<EnumConstantDecl>(value));
 848     EmitDeclRefExprDbgValue(refExpr, C);
 849   }
 850
 851   // If we emitted a reference constant, we need to dereference that.
 852   if (resultIsReference)
 853     return ConstantEmission::forReference(C);
 854
 855   return ConstantEmission::forValue(C);
 856 }
 857
 858 llvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue) {
 859   return EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatile(),
 860                           lvalue.getAlignment().getQuantity(),
 861                           lvalue.getType(), lvalue.getTBAAInfo());
 862 }
 863
 864 static bool hasBooleanRepresentation(QualType Ty) {
 865   if (Ty->isBooleanType())
 866     return true;
 867
 868   if (const EnumType *ET = Ty->getAs<EnumType>())
 869     return ET->getDecl()->getIntegerType()->isBooleanType();
 870
 871   if (const AtomicType *AT = Ty->getAs<AtomicType>())
 872     return hasBooleanRepresentation(AT->getValueType());
 873
 874   return false;
 875 }
 876
 877 llvm::MDNode *CodeGenFunction::getRangeForLoadFromType(QualType Ty) {
 878   const EnumType *ET = Ty->getAs<EnumType>();
 879   bool IsRegularCPlusPlusEnum = (getLangOpts().CPlusPlus && ET &&
 880                                  CGM.getCodeGenOpts().StrictEnums &&
 881                                  !ET->getDecl()->isFixed());
 882   bool IsBool = hasBooleanRepresentation(Ty);
 883   llvm::Type *LTy;
 884   if (!IsBool && !IsRegularCPlusPlusEnum)
 885     return NULL;
 886
 887   llvm::APInt Min;
 888   llvm::APInt End;
 889   if (IsBool) {
 890     Min = llvm::APInt(8, 0);
 891     End = llvm::APInt(8, 2);
 892     LTy = Int8Ty;
 893   } else {
 894     const EnumDecl *ED = ET->getDecl();
 895     LTy = ConvertTypeForMem(ED->getIntegerType());
 896     unsigned Bitwidth = LTy->getScalarSizeInBits();
 897     unsigned NumNegativeBits = ED->getNumNegativeBits();
 898     unsigned NumPositiveBits = ED->getNumPositiveBits();
 899
 900     if (NumNegativeBits) {
 901       unsigned NumBits = std::max(NumNegativeBits, NumPositiveBits + 1);
 902       assert(NumBits <= Bitwidth);
 903       End = llvm::APInt(Bitwidth, 1) << (NumBits - 1);
 904       Min = -End;
 905     } else {
 906       assert(NumPositiveBits <= Bitwidth);
 907       End = llvm::APInt(Bitwidth, 1) << NumPositiveBits;
 908       Min = llvm::APInt(Bitwidth, 0);
 909     }
 910   }
 911
 912   llvm::MDBuilder MDHelper(getLLVMContext());
 913   return MDHelper.createRange(Min, End);
 914 }
 915
 916 llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
 917                                               unsigned Alignment, QualType Ty,
 918                                               llvm::MDNode *TBAAInfo) {
 919   llvm::LoadInst *Load = Builder.CreateLoad(Addr);
 920   if (Volatile)
 921     Load->setVolatile(true);
 922   if (Alignment)
 923     Load->setAlignment(Alignment);
 924   if (TBAAInfo)
 925     CGM.DecorateInstruction(Load, TBAAInfo);
 926   // If this is an atomic type, all normal reads must be atomic
 927   if (Ty->isAtomicType())
 928     Load->setAtomic(llvm::SequentiallyConsistent);
 929
 930   if (CGM.getCodeGenOpts().OptimizationLevel > 0)
 931     if (llvm::MDNode *RangeInfo = getRangeForLoadFromType(Ty))
 932       Load->setMetadata(llvm::LLVMContext::MD_range, RangeInfo);
 933
 934   return EmitFromMemory(Load, Ty);
 935 }
 936
 937 llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) {
 938   // Bool has a different representation in memory than in registers.
 939   if (hasBooleanRepresentation(Ty)) {
 940     // This should really always be an i1, but sometimes it's already
 941     // an i8, and it's awkward to track those cases down.
 942     if (Value->getType()->isIntegerTy(1))
 943       return Builder.CreateZExt(Value, Builder.getInt8Ty(), "frombool");
 944     assert(Value->getType()->isIntegerTy(8) && "value rep of bool not i1/i8");
 945   }
 946
 947   return Value;
 948 }
 949
 950 llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) {
 951   // Bool has a different representation in memory than in registers.
 952   if (hasBooleanRepresentation(Ty)) {
 953     assert(Value->getType()->isIntegerTy(8) && "memory rep of bool not i8");
 954     return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool");
 955   }
 956
 957   return Value;
 958 }
 959
 960 void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
 961                                         bool Volatile, unsigned Alignment,
 962                                         QualType Ty,
 963                                         llvm::MDNode *TBAAInfo,
 964                                         bool isInit) {
 965   Value = EmitToMemory(Value, Ty);
 966
 967   llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile);
 968   if (Alignment)
 969     Store->setAlignment(Alignment);
 970   if (TBAAInfo)
 971     CGM.DecorateInstruction(Store, TBAAInfo);
 972   if (!isInit && Ty->isAtomicType())
 973     Store->setAtomic(llvm::SequentiallyConsistent);
 974 }
 975
 976 void CodeGenFunction::EmitStoreOfScalar(llvm::Value *value, LValue lvalue,
 977     bool isInit) {
 978   EmitStoreOfScalar(value, lvalue.getAddress(), lvalue.isVolatile(),
 979                     lvalue.getAlignment().getQuantity(), lvalue.getType(),
 980                     lvalue.getTBAAInfo(), isInit);
 981 }
 982
 983 /// EmitLoadOfLValue - Given an expression that represents a value lvalue, this
 984 /// method emits the address of the lvalue, then loads the result as an rvalue,
 985 /// returning the rvalue.
 986 RValue CodeGenFunction::EmitLoadOfLValue(LValue LV) {
 987   if (LV.isObjCWeak()) {
 988     // load of a __weak object.
 989     llvm::Value *AddrWeakObj = LV.getAddress();
 990     return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this,
 991                                                              AddrWeakObj));
 992   }
 993   if (LV.getQuals().getObjCLifetime() == Qualifiers::OCL_Weak)
 994     return RValue::get(EmitARCLoadWeak(LV.getAddress()));
 995
 996   if (LV.isSimple()) {
 997     assert(!LV.getType()->isFunctionType());
 998
 999     // Everything needs a load.
1000     return RValue::get(EmitLoadOfScalar(LV));
1001   }
1002
1003   if (LV.isVectorElt()) {
1004     llvm::LoadInst *Load = Builder.CreateLoad(LV.getVectorAddr(),
1005                                               LV.isVolatileQualified());
1006     Load->setAlignment(LV.getAlignment().getQuantity());
1007     return RValue::get(Builder.CreateExtractElement(Load, LV.getVectorIdx(),
1008                                                     "vecext"));
1009   }
1010
1011   // If this is a reference to a subset of the elements of a vector, either
1012   // shuffle the input or extract/insert them as appropriate.
1013   if (LV.isExtVectorElt())
1014     return EmitLoadOfExtVectorElementLValue(LV);
1015
1016   assert(LV.isBitField() && "Unknown LValue type!");
1017   return EmitLoadOfBitfieldLValue(LV);
1018 }
1019
1020 RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV) {
1021   const CGBitFieldInfo &Info = LV.getBitFieldInfo();
1022
1023   // Get the output type.
1024   llvm::Type *ResLTy = ConvertType(LV.getType());
1025   unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
1026
1027   // Compute the result as an OR of all of the individual component accesses.
1028   llvm::Value *Res = 0;
1029   for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
1030     const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
1031
1032     // Get the field pointer.
1033     llvm::Value *Ptr = LV.getBitFieldBaseAddr();
1034
1035     // Only offset by the field index if used, so that incoming values are not
1036     // required to be structures.
1037     if (AI.FieldIndex)
1038       Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
1039
1040     // Offset by the byte offset, if used.
1041     if (!AI.FieldByteOffset.isZero()) {
1042       Ptr = EmitCastToVoidPtr(Ptr);
1043       Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(),
1044                                        "bf.field.offs");
1045     }
1046
1047     // Cast to the access type.
1048     llvm::Type *PTy = llvm::Type::getIntNPtrTy(getLLVMContext(), AI.AccessWidth,
1049                        CGM.getContext().getTargetAddressSpace(LV.getType()));
1050     Ptr = Builder.CreateBitCast(Ptr, PTy);
1051
1052     // Perform the load.
1053     llvm::LoadInst *Load = Builder.CreateLoad(Ptr, LV.isVolatileQualified());
1054     if (!AI.AccessAlignment.isZero())
1055       Load->setAlignment(AI.AccessAlignment.getQuantity());
1056
1057     // Shift out unused low bits and mask out unused high bits.
1058     llvm::Value *Val = Load;
1059     if (AI.FieldBitStart)
1060       Val = Builder.CreateLShr(Load, AI.FieldBitStart);
1061     Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(AI.AccessWidth,
1062                                                             AI.TargetBitWidth),
1063                             "bf.clear");
1064
1065     // Extend or truncate to the target size.
1066     if (AI.AccessWidth < ResSizeInBits)
1067       Val = Builder.CreateZExt(Val, ResLTy);
1068     else if (AI.AccessWidth > ResSizeInBits)
1069       Val = Builder.CreateTrunc(Val, ResLTy);
1070
1071     // Shift into place, and OR into the result.
1072     if (AI.TargetBitOffset)
1073       Val = Builder.CreateShl(Val, AI.TargetBitOffset);
1074     Res = Res ? Builder.CreateOr(Res, Val) : Val;
1075   }
1076
1077   // If the bit-field is signed, perform the sign-extension.
1078   //
1079   // FIXME: This can easily be folded into the load of the high bits, which
1080   // could also eliminate the mask of high bits in some situations.
1081   if (Info.isSigned()) {
1082     unsigned ExtraBits = ResSizeInBits - Info.getSize();
1083     if (ExtraBits)
1084       Res = Builder.CreateAShr(Builder.CreateShl(Res, ExtraBits),
1085                                ExtraBits, "bf.val.sext");
1086   }
1087
1088   return RValue::get(Res);
1089 }
1090
1091 // If this is a reference to a subset of the elements of a vector, create an
1092 // appropriate shufflevector.
1093 RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) {
1094   llvm::LoadInst *Load = Builder.CreateLoad(LV.getExtVectorAddr(),
1095                                             LV.isVolatileQualified());
1096   Load->setAlignment(LV.getAlignment().getQuantity());
1097   llvm::Value *Vec = Load;
1098
1099   const llvm::Constant *Elts = LV.getExtVectorElts();
1100
1101   // If the result of the expression is a non-vector type, we must be extracting
1102   // a single element.  Just codegen as an extractelement.
1103   const VectorType *ExprVT = LV.getType()->getAs<VectorType>();
1104   if (!ExprVT) {
1105     unsigned InIdx = getAccessedFieldNo(0, Elts);
1106     llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
1107     return RValue::get(Builder.CreateExtractElement(Vec, Elt));
1108   }
1109
1110   // Always use shuffle vector to try to retain the original program structure
1111   unsigned NumResultElts = ExprVT->getNumElements();
1112
1113   SmallVector<llvm::Constant*, 4> Mask;
1114   for (unsigned i = 0; i != NumResultElts; ++i)
1115     Mask.push_back(Builder.getInt32(getAccessedFieldNo(i, Elts)));
1116
1117   llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1118   Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()),
1119                                     MaskV);
1120   return RValue::get(Vec);
1121 }
1122
1123
1124
1125 /// EmitStoreThroughLValue - Store the specified rvalue into the specified
1126 /// lvalue, where both are guaranteed to the have the same type, and that type
1127 /// is 'Ty'.
1128 void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit) {
1129   if (!Dst.isSimple()) {
1130     if (Dst.isVectorElt()) {
1131       // Read/modify/write the vector, inserting the new element.
1132       llvm::LoadInst *Load = Builder.CreateLoad(Dst.getVectorAddr(),
1133                                                 Dst.isVolatileQualified());
1134       Load->setAlignment(Dst.getAlignment().getQuantity());
1135       llvm::Value *Vec = Load;
1136       Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
1137                                         Dst.getVectorIdx(), "vecins");
1138       llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getVectorAddr(),
1139                                                    Dst.isVolatileQualified());
1140       Store->setAlignment(Dst.getAlignment().getQuantity());
1141       return;
1142     }
1143
1144     // If this is an update of extended vector elements, insert them as
1145     // appropriate.
1146     if (Dst.isExtVectorElt())
1147       return EmitStoreThroughExtVectorComponentLValue(Src, Dst);
1148
1149     assert(Dst.isBitField() && "Unknown LValue type");
1150     return EmitStoreThroughBitfieldLValue(Src, Dst);
1151   }
1152
1153   // There's special magic for assigning into an ARC-qualified l-value.
1154   if (Qualifiers::ObjCLifetime Lifetime = Dst.getQuals().getObjCLifetime()) {
1155     switch (Lifetime) {
1156     case Qualifiers::OCL_None:
1157       llvm_unreachable("present but none");
1158
1159     case Qualifiers::OCL_ExplicitNone:
1160       // nothing special
1161       break;
1162
1163     case Qualifiers::OCL_Strong:
1164       EmitARCStoreStrong(Dst, Src.getScalarVal(), /*ignore*/ true);
1165       return;
1166
1167     case Qualifiers::OCL_Weak:
1168       EmitARCStoreWeak(Dst.getAddress(), Src.getScalarVal(), /*ignore*/ true);
1169       return;
1170
1171     case Qualifiers::OCL_Autoreleasing:
1172       Src = RValue::get(EmitObjCExtendObjectLifetime(Dst.getType(),
1173                                                      Src.getScalarVal()));
1174       // fall into the normal path
1175       break;
1176     }
1177   }
1178
1179   if (Dst.isObjCWeak() && !Dst.isNonGC()) {
1180     // load of a __weak object.
1181     llvm::Value *LvalueDst = Dst.getAddress();
1182     llvm::Value *src = Src.getScalarVal();
1183      CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst);
1184     return;
1185   }
1186
1187   if (Dst.isObjCStrong() && !Dst.isNonGC()) {
1188     // load of a __strong object.
1189     llvm::Value *LvalueDst = Dst.getAddress();
1190     llvm::Value *src = Src.getScalarVal();
1191     if (Dst.isObjCIvar()) {
1192       assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL");
1193       llvm::Type *ResultType = ConvertType(getContext().LongTy);
1194       llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp());
1195       llvm::Value *dst = RHS;
1196       RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
1197       llvm::Value *LHS =
1198         Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast");
1199       llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset");
1200       CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst,
1201                                               BytesBetween);
1202     } else if (Dst.isGlobalObjCRef()) {
1203       CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst,
1204                                                 Dst.isThreadLocalRef());
1205     }
1206     else
1207       CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst);
1208     return;
1209   }
1210
1211   assert(Src.isScalar() && "Can't emit an agg store with this method");
1212   EmitStoreOfScalar(Src.getScalarVal(), Dst, isInit);
1213 }
1214
1215 void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
1216                                                      llvm::Value **Result) {
1217   const CGBitFieldInfo &Info = Dst.getBitFieldInfo();
1218
1219   // Get the output type.
1220   llvm::Type *ResLTy = ConvertTypeForMem(Dst.getType());
1221   unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
1222
1223   // Get the source value, truncated to the width of the bit-field.
1224   llvm::Value *SrcVal = Src.getScalarVal();
1225
1226   if (hasBooleanRepresentation(Dst.getType()))
1227     SrcVal = Builder.CreateIntCast(SrcVal, ResLTy, /*IsSigned=*/false);
1228
1229   SrcVal = Builder.CreateAnd(SrcVal, llvm::APInt::getLowBitsSet(ResSizeInBits,
1230                                                                 Info.getSize()),
1231                              "bf.value");
1232
1233   // Return the new value of the bit-field, if requested.
1234   if (Result) {
1235     // Cast back to the proper type for result.
1236     llvm::Type *SrcTy = Src.getScalarVal()->getType();
1237     llvm::Value *ReloadVal = Builder.CreateIntCast(SrcVal, SrcTy, false,
1238                                                    "bf.reload.val");
1239
1240     // Sign extend if necessary.
1241     if (Info.isSigned()) {
1242       unsigned ExtraBits = ResSizeInBits - Info.getSize();
1243       if (ExtraBits)
1244         ReloadVal = Builder.CreateAShr(Builder.CreateShl(ReloadVal, ExtraBits),
1245                                        ExtraBits, "bf.reload.sext");
1246     }
1247
1248     *Result = ReloadVal;
1249   }
1250
1251   // Iterate over the components, writing each piece to memory.
1252   for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
1253     const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
1254
1255     // Get the field pointer.
1256     llvm::Value *Ptr = Dst.getBitFieldBaseAddr();
1257     unsigned addressSpace =
1258       cast<llvm::PointerType>(Ptr->getType())->getAddressSpace();
1259
1260     // Only offset by the field index if used, so that incoming values are not
1261     // required to be structures.
1262     if (AI.FieldIndex)
1263       Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
1264
1265     // Offset by the byte offset, if used.
1266     if (!AI.FieldByteOffset.isZero()) {
1267       Ptr = EmitCastToVoidPtr(Ptr);
1268       Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(),
1269                                        "bf.field.offs");
1270     }
1271
1272     // Cast to the access type.
1273     llvm::Type *AccessLTy =
1274       llvm::Type::getIntNTy(getLLVMContext(), AI.AccessWidth);
1275
1276     llvm::Type *PTy = AccessLTy->getPointerTo(addressSpace);
1277     Ptr = Builder.CreateBitCast(Ptr, PTy);
1278
1279     // Extract the piece of the bit-field value to write in this access, limited
1280     // to the values that are part of this access.
1281     llvm::Value *Val = SrcVal;
1282     if (AI.TargetBitOffset)
1283       Val = Builder.CreateLShr(Val, AI.TargetBitOffset);
1284     Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(ResSizeInBits,
1285                                                             AI.TargetBitWidth));
1286
1287     // Extend or truncate to the access size.
1288     if (ResSizeInBits < AI.AccessWidth)
1289       Val = Builder.CreateZExt(Val, AccessLTy);
1290     else if (ResSizeInBits > AI.AccessWidth)
1291       Val = Builder.CreateTrunc(Val, AccessLTy);
1292
1293     // Shift into the position in memory.
1294     if (AI.FieldBitStart)
1295       Val = Builder.CreateShl(Val, AI.FieldBitStart);
1296
1297     // If necessary, load and OR in bits that are outside of the bit-field.
1298     if (AI.TargetBitWidth != AI.AccessWidth) {
1299       llvm::LoadInst *Load = Builder.CreateLoad(Ptr, Dst.isVolatileQualified());
1300       if (!AI.AccessAlignment.isZero())
1301         Load->setAlignment(AI.AccessAlignment.getQuantity());
1302
1303       // Compute the mask for zeroing the bits that are part of the bit-field.
1304       llvm::APInt InvMask =
1305         ~llvm::APInt::getBitsSet(AI.AccessWidth, AI.FieldBitStart,
1306                                  AI.FieldBitStart + AI.TargetBitWidth);
1307
1308       // Apply the mask and OR in to the value to write.
1309       Val = Builder.CreateOr(Builder.CreateAnd(Load, InvMask), Val);
1310     }
1311
1312     // Write the value.
1313     llvm::StoreInst *Store = Builder.CreateStore(Val, Ptr,
1314                                                  Dst.isVolatileQualified());
1315     if (!AI.AccessAlignment.isZero())
1316       Store->setAlignment(AI.AccessAlignment.getQuantity());
1317   }
1318 }
1319
1320 void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
1321                                                                LValue Dst) {
1322   // This access turns into a read/modify/write of the vector.  Load the input
1323   // value now.
1324   llvm::LoadInst *Load = Builder.CreateLoad(Dst.getExtVectorAddr(),
1325                                             Dst.isVolatileQualified());
1326   Load->setAlignment(Dst.getAlignment().getQuantity());
1327   llvm::Value *Vec = Load;
1328   const llvm::Constant *Elts = Dst.getExtVectorElts();
1329
1330   llvm::Value *SrcVal = Src.getScalarVal();
1331
1332   if (const VectorType *VTy = Dst.getType()->getAs<VectorType>()) {
1333     unsigned NumSrcElts = VTy->getNumElements();
1334     unsigned NumDstElts =
1335        cast<llvm::VectorType>(Vec->getType())->getNumElements();
1336     if (NumDstElts == NumSrcElts) {
1337       // Use shuffle vector is the src and destination are the same number of
1338       // elements and restore the vector mask since it is on the side it will be
1339       // stored.
1340       SmallVector<llvm::Constant*, 4> Mask(NumDstElts);
1341       for (unsigned i = 0; i != NumSrcElts; ++i)
1342         Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i);
1343
1344       llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1345       Vec = Builder.CreateShuffleVector(SrcVal,
1346                                         llvm::UndefValue::get(Vec->getType()),
1347                                         MaskV);
1348     } else if (NumDstElts > NumSrcElts) {
1349       // Extended the source vector to the same length and then shuffle it
1350       // into the destination.
1351       // FIXME: since we're shuffling with undef, can we just use the indices
1352       //        into that?  This could be simpler.
1353       SmallVector<llvm::Constant*, 4> ExtMask;
1354       for (unsigned i = 0; i != NumSrcElts; ++i)
1355         ExtMask.push_back(Builder.getInt32(i));
1356       ExtMask.resize(NumDstElts, llvm::UndefValue::get(Int32Ty));
1357       llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask);
1358       llvm::Value *ExtSrcVal =
1359         Builder.CreateShuffleVector(SrcVal,
1360                                     llvm::UndefValue::get(SrcVal->getType()),
1361                                     ExtMaskV);
1362       // build identity
1363       SmallVector<llvm::Constant*, 4> Mask;
1364       for (unsigned i = 0; i != NumDstElts; ++i)
1365         Mask.push_back(Builder.getInt32(i));
1366
1367       // modify when what gets shuffled in
1368       for (unsigned i = 0; i != NumSrcElts; ++i)
1369         Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i+NumDstElts);
1370       llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1371       Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV);
1372     } else {
1373       // We should never shorten the vector
1374       llvm_unreachable("unexpected shorten vector length");
1375     }
1376   } else {
1377     // If the Src is a scalar (not a vector) it must be updating one element.
1378     unsigned InIdx = getAccessedFieldNo(0, Elts);
1379     llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
1380     Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt);
1381   }
1382
1383   llvm::StoreInst *Store = Builder.CreateStore(Vec, Dst.getExtVectorAddr(),
1384                                                Dst.isVolatileQualified());
1385   Store->setAlignment(Dst.getAlignment().getQuantity());
1386 }
1387
1388 // setObjCGCLValueClass - sets class of he lvalue for the purpose of
1389 // generating write-barries API. It is currently a global, ivar,
1390 // or neither.
1391 static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E,
1392                                  LValue &LV,
1393                                  bool IsMemberAccess=false) {
1394   if (Ctx.getLangOpts().getGC() == LangOptions::NonGC)
1395     return;
1396
1397   if (isa<ObjCIvarRefExpr>(E)) {
1398     QualType ExpTy = E->getType();
1399     if (IsMemberAccess && ExpTy->isPointerType()) {
1400       // If ivar is a structure pointer, assigning to field of
1401       // this struct follows gcc's behavior and makes it a non-ivar
1402       // writer-barrier conservatively.
1403       ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1404       if (ExpTy->isRecordType()) {
1405         LV.setObjCIvar(false);
1406         return;
1407       }
1408     }
1409     LV.setObjCIvar(true);
1410     ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E));
1411     LV.setBaseIvarExp(Exp->getBase());
1412     LV.setObjCArray(E->getType()->isArrayType());
1413     return;
1414   }
1415
1416   if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) {
1417     if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
1418       if (VD->hasGlobalStorage()) {
1419         LV.setGlobalObjCRef(true);
1420         LV.setThreadLocalRef(VD->isThreadSpecified());
1421       }
1422     }
1423     LV.setObjCArray(E->getType()->isArrayType());
1424     return;
1425   }
1426
1427   if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) {
1428     setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
1429     return;
1430   }
1431
1432   if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) {
1433     setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
1434     if (LV.isObjCIvar()) {
1435       // If cast is to a structure pointer, follow gcc's behavior and make it
1436       // a non-ivar write-barrier.
1437       QualType ExpTy = E->getType();
1438       if (ExpTy->isPointerType())
1439         ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1440       if (ExpTy->isRecordType())
1441         LV.setObjCIvar(false);
1442     }
1443     return;
1444   }
1445
1446   if (const GenericSelectionExpr *Exp = dyn_cast<GenericSelectionExpr>(E)) {
1447     setObjCGCLValueClass(Ctx, Exp->getResultExpr(), LV);
1448     return;
1449   }
1450
1451   if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) {
1452     setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
1453     return;
1454   }
1455
1456   if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) {
1457     setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
1458     return;
1459   }
1460
1461   if (const ObjCBridgedCastExpr *Exp = dyn_cast<ObjCBridgedCastExpr>(E)) {
1462     setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
1463     return;
1464   }
1465
1466   if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
1467     setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
1468     if (LV.isObjCIvar() && !LV.isObjCArray())
1469       // Using array syntax to assigning to what an ivar points to is not
1470       // same as assigning to the ivar itself. {id *Names;} Names[i] = 0;
1471       LV.setObjCIvar(false);
1472     else if (LV.isGlobalObjCRef() && !LV.isObjCArray())
1473       // Using array syntax to assigning to what global points to is not
1474       // same as assigning to the global itself. {id *G;} G[i] = 0;
1475       LV.setGlobalObjCRef(false);
1476     return;
1477   }
1478
1479   if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) {
1480     setObjCGCLValueClass(Ctx, Exp->getBase(), LV, true);
1481     // We don't know if member is an 'ivar', but this flag is looked at
1482     // only in the context of LV.isObjCIvar().
1483     LV.setObjCArray(E->getType()->isArrayType());
1484     return;
1485   }
1486 }
1487
1488 static llvm::Value *
1489 EmitBitCastOfLValueToProperType(CodeGenFunction &CGF,
1490                                 llvm::Value *V, llvm::Type *IRType,
1491                                 StringRef Name = StringRef()) {
1492   unsigned AS = cast<llvm::PointerType>(V->getType())->getAddressSpace();
1493   return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name);
1494 }
1495
1496 static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF,
1497                                       const Expr *E, const VarDecl *VD) {
1498   assert((VD->hasExternalStorage() || VD->isFileVarDecl()) &&
1499          "Var decl must have external storage or be a file var decl!");
1500
1501   llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD);
1502   llvm::Type *RealVarTy = CGF.getTypes().ConvertTypeForMem(VD->getType());
1503   V = EmitBitCastOfLValueToProperType(CGF, V, RealVarTy);
1504   CharUnits Alignment = CGF.getContext().getDeclAlign(VD);
1505   QualType T = E->getType();
1506   LValue LV;
1507   if (VD->getType()->isReferenceType()) {
1508     llvm::LoadInst *LI = CGF.Builder.CreateLoad(V);
1509     LI->setAlignment(Alignment.getQuantity());
1510     V = LI;
1511     LV = CGF.MakeNaturalAlignAddrLValue(V, T);
1512   } else {
1513     LV = CGF.MakeAddrLValue(V, E->getType(), Alignment);
1514   }
1515   setObjCGCLValueClass(CGF.getContext(), E, LV);
1516   return LV;
1517 }
1518
1519 static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF,
1520                                      const Expr *E, const FunctionDecl *FD) {
1521   llvm::Value *V = CGF.CGM.GetAddrOfFunction(FD);
1522   if (!FD->hasPrototype()) {
1523     if (const FunctionProtoType *Proto =
1524             FD->getType()->getAs<FunctionProtoType>()) {
1525       // Ugly case: for a K&R-style definition, the type of the definition
1526       // isn't the same as the type of a use.  Correct for this with a
1527       // bitcast.
1528       QualType NoProtoType =
1529           CGF.getContext().getFunctionNoProtoType(Proto->getResultType());
1530       NoProtoType = CGF.getContext().getPointerType(NoProtoType);
1531       V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType));
1532     }
1533   }
1534   CharUnits Alignment = CGF.getContext().getDeclAlign(FD);
1535   return CGF.MakeAddrLValue(V, E->getType(), Alignment);
1536 }
1537
1538 LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
1539   const NamedDecl *ND = E->getDecl();
1540   CharUnits Alignment = getContext().getDeclAlign(ND);
1541   QualType T = E->getType();
1542
1543   // FIXME: We should be able to assert this for FunctionDecls as well!
1544   // FIXME: We should be able to assert this for all DeclRefExprs, not just
1545   // those with a valid source location.
1546   assert((ND->isUsed(false) || !isa<VarDecl>(ND) ||
1547           !E->getLocation().isValid()) &&
1548          "Should not use decl without marking it used!");
1549
1550   if (ND->hasAttr<WeakRefAttr>()) {
1551     const ValueDecl *VD = cast<ValueDecl>(ND);
1552     llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD);
1553     return MakeAddrLValue(Aliasee, E->getType(), Alignment);
1554   }
1555
1556   if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
1557     // Check if this is a global variable.
1558     if (VD->hasExternalStorage() || VD->isFileVarDecl())
1559       return EmitGlobalVarDeclLValue(*this, E, VD);
1560
1561     bool isBlockVariable = VD->hasAttr<BlocksAttr>();
1562
1563     bool NonGCable = VD->hasLocalStorage() &&
1564                      !VD->getType()->isReferenceType() &&
1565                      !isBlockVariable;
1566
1567     llvm::Value *V = LocalDeclMap[VD];
1568     if (!V && VD->isStaticLocal())
1569       V = CGM.getStaticLocalDeclAddress(VD);
1570
1571     // Use special handling for lambdas.
1572     if (!V) {
1573       if (FieldDecl *FD = LambdaCaptureFields.lookup(VD)) {
1574         QualType LambdaTagType = getContext().getTagDeclType(FD->getParent());
1575         LValue LambdaLV = MakeNaturalAlignAddrLValue(CXXABIThisValue,
1576                                                      LambdaTagType);
1577         return EmitLValueForField(LambdaLV, FD);
1578       }
1579
1580       assert(isa<BlockDecl>(CurCodeDecl) && E->refersToEnclosingLocal());
1581       CharUnits alignment = getContext().getDeclAlign(VD);
1582       return MakeAddrLValue(GetAddrOfBlockDecl(VD, isBlockVariable),
1583                             E->getType(), alignment);
1584     }
1585
1586     assert(V && "DeclRefExpr not entered in LocalDeclMap?");
1587
1588     if (isBlockVariable)
1589       V = BuildBlockByrefAddress(V, VD);
1590
1591     LValue LV;
1592     if (VD->getType()->isReferenceType()) {
1593       llvm::LoadInst *LI = Builder.CreateLoad(V);
1594       LI->setAlignment(Alignment.getQuantity());
1595       V = LI;
1596       LV = MakeNaturalAlignAddrLValue(V, T);
1597     } else {
1598       LV = MakeAddrLValue(V, T, Alignment);
1599     }
1600
1601     if (NonGCable) {
1602       LV.getQuals().removeObjCGCAttr();
1603       LV.setNonGC(true);
1604     }
1605     setObjCGCLValueClass(getContext(), E, LV);
1606     return LV;
1607   }
1608
1609   if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND))
1610     return EmitFunctionDeclLValue(*this, E, fn);
1611
1612   llvm_unreachable("Unhandled DeclRefExpr");
1613 }
1614
1615 LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
1616   // __extension__ doesn't affect lvalue-ness.
1617   if (E->getOpcode() == UO_Extension)
1618     return EmitLValue(E->getSubExpr());
1619
1620   QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType());
1621   switch (E->getOpcode()) {
1622   default: llvm_unreachable("Unknown unary operator lvalue!");
1623   case UO_Deref: {
1624     QualType T = E->getSubExpr()->getType()->getPointeeType();
1625     assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type");
1626
1627     LValue LV = MakeNaturalAlignAddrLValue(EmitScalarExpr(E->getSubExpr()), T);
1628     LV.getQuals().setAddressSpace(ExprTy.getAddressSpace());
1629
1630     // We should not generate __weak write barrier on indirect reference
1631     // of a pointer to object; as in void foo (__weak id *param); *param = 0;
1632     // But, we continue to generate __strong write barrier on indirect write
1633     // into a pointer to object.
1634     if (getContext().getLangOpts().ObjC1 &&
1635         getContext().getLangOpts().getGC() != LangOptions::NonGC &&
1636         LV.isObjCWeak())
1637       LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
1638     return LV;
1639   }
1640   case UO_Real:
1641   case UO_Imag: {
1642     LValue LV = EmitLValue(E->getSubExpr());
1643     assert(LV.isSimple() && "real/imag on non-ordinary l-value");
1644     llvm::Value *Addr = LV.getAddress();
1645
1646     // __real is valid on scalars.  This is a faster way of testing that.
1647     // __imag can only produce an rvalue on scalars.
1648     if (E->getOpcode() == UO_Real &&
1649         !cast<llvm::PointerType>(Addr->getType())
1650            ->getElementType()->isStructTy()) {
1651       assert(E->getSubExpr()->getType()->isArithmeticType());
1652       return LV;
1653     }
1654
1655     assert(E->getSubExpr()->getType()->isAnyComplexType());
1656
1657     unsigned Idx = E->getOpcode() == UO_Imag;
1658     return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(),
1659                                                   Idx, "idx"),
1660                           ExprTy);
1661   }
1662   case UO_PreInc:
1663   case UO_PreDec: {
1664     LValue LV = EmitLValue(E->getSubExpr());
1665     bool isInc = E->getOpcode() == UO_PreInc;
1666
1667     if (E->getType()->isAnyComplexType())
1668       EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/);
1669     else
1670       EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/);
1671     return LV;
1672   }
1673   }
1674 }
1675
1676 LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
1677   return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E),
1678                         E->getType());
1679 }
1680
1681 LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
1682   return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E),
1683                         E->getType());
1684 }
1685
1686
1687 LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
1688   switch (E->getIdentType()) {
1689   default:
1690     return EmitUnsupportedLValue(E, "predefined expression");
1691
1692   case PredefinedExpr::Func:
1693   case PredefinedExpr::Function:
1694   case PredefinedExpr::PrettyFunction: {
1695     unsigned Type = E->getIdentType();
1696     std::string GlobalVarName;
1697
1698     switch (Type) {
1699     default: llvm_unreachable("Invalid type");
1700     case PredefinedExpr::Func:
1701       GlobalVarName = "__func__.";
1702       break;
1703     case PredefinedExpr::Function:
1704       GlobalVarName = "__FUNCTION__.";
1705       break;
1706     case PredefinedExpr::PrettyFunction:
1707       GlobalVarName = "__PRETTY_FUNCTION__.";
1708       break;
1709     }
1710
1711     StringRef FnName = CurFn->getName();
1712     if (FnName.startswith("\01"))
1713       FnName = FnName.substr(1);
1714     GlobalVarName += FnName;
1715
1716     const Decl *CurDecl = CurCodeDecl;
1717     if (CurDecl == 0)
1718       CurDecl = getContext().getTranslationUnitDecl();
1719
1720     std::string FunctionName =
1721         (isa<BlockDecl>(CurDecl)
1722          ? FnName.str()
1723          : PredefinedExpr::ComputeName((PredefinedExpr::IdentType)Type, CurDecl));
1724
1725     llvm::Constant *C =
1726       CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str());
1727     return MakeAddrLValue(C, E->getType());
1728   }
1729   }
1730 }
1731
1732 llvm::BasicBlock *CodeGenFunction::getTrapBB() {
1733   const CodeGenOptions &GCO = CGM.getCodeGenOpts();
1734
1735   // If we are not optimzing, don't collapse all calls to trap in the function
1736   // to the same call, that way, in the debugger they can see which operation
1737   // did in fact fail.  If we are optimizing, we collapse all calls to trap down
1738   // to just one per function to save on codesize.
1739   if (GCO.OptimizationLevel && TrapBB)
1740     return TrapBB;
1741
1742   llvm::BasicBlock *Cont = 0;
1743   if (HaveInsertPoint()) {
1744     Cont = createBasicBlock("cont");
1745     EmitBranch(Cont);
1746   }
1747   TrapBB = createBasicBlock("trap");
1748   EmitBlock(TrapBB);
1749
1750   llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap);
1751   llvm::CallInst *TrapCall = Builder.CreateCall(F);
1752   TrapCall->setDoesNotReturn();
1753   TrapCall->setDoesNotThrow();
1754   Builder.CreateUnreachable();
1755
1756   if (Cont)
1757     EmitBlock(Cont);
1758   return TrapBB;
1759 }
1760
1761 /// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an
1762 /// array to pointer, return the array subexpression.
1763 static const Expr *isSimpleArrayDecayOperand(const Expr *E) {
1764   // If this isn't just an array->pointer decay, bail out.
1765   const CastExpr *CE = dyn_cast<CastExpr>(E);
1766   if (CE == 0 || CE->getCastKind() != CK_ArrayToPointerDecay)
1767     return 0;
1768
1769   // If this is a decay from variable width array, bail out.
1770   const Expr *SubExpr = CE->getSubExpr();
1771   if (SubExpr->getType()->isVariableArrayType())
1772     return 0;
1773
1774   return SubExpr;
1775 }
1776
1777 LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
1778   // The index must always be an integer, which is not an aggregate.  Emit it.
1779   llvm::Value *Idx = EmitScalarExpr(E->getIdx());
1780   QualType IdxTy  = E->getIdx()->getType();
1781   bool IdxSigned = IdxTy->isSignedIntegerOrEnumerationType();
1782
1783   // If the base is a vector type, then we are forming a vector element lvalue
1784   // with this subscript.
1785   if (E->getBase()->getType()->isVectorType()) {
1786     // Emit the vector as an lvalue to get its address.
1787     LValue LHS = EmitLValue(E->getBase());
1788     assert(LHS.isSimple() && "Can only subscript lvalue vectors here!");
1789     Idx = Builder.CreateIntCast(Idx, Int32Ty, IdxSigned, "vidx");
1790     return LValue::MakeVectorElt(LHS.getAddress(), Idx,
1791                                  E->getBase()->getType(), LHS.getAlignment());
1792   }
1793
1794   // Extend or truncate the index type to 32 or 64-bits.
1795   if (Idx->getType() != IntPtrTy)
1796     Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom");
1797
1798   // FIXME: As llvm implements the object size checking, this can come out.
1799   if (CatchUndefined) {
1800     if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E->getBase())){
1801       if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) {
1802         if (ICE->getCastKind() == CK_ArrayToPointerDecay) {
1803           if (const ConstantArrayType *CAT
1804               = getContext().getAsConstantArrayType(DRE->getType())) {
1805             llvm::APInt Size = CAT->getSize();
1806             llvm::BasicBlock *Cont = createBasicBlock("cont");
1807             Builder.CreateCondBr(Builder.CreateICmpULE(Idx,
1808                                   llvm::ConstantInt::get(Idx->getType(), Size)),
1809                                  Cont, getTrapBB());
1810             EmitBlock(Cont);
1811           }
1812         }
1813       }
1814     }
1815   }
1816
1817   // We know that the pointer points to a type of the correct size, unless the
1818   // size is a VLA or Objective-C interface.
1819   llvm::Value *Address = 0;
1820   CharUnits ArrayAlignment;
1821   if (const VariableArrayType *vla =
1822         getContext().getAsVariableArrayType(E->getType())) {
1823     // The base must be a pointer, which is not an aggregate.  Emit
1824     // it.  It needs to be emitted first in case it's what captures
1825     // the VLA bounds.
1826     Address = EmitScalarExpr(E->getBase());
1827
1828     // The element count here is the total number of non-VLA elements.
1829     llvm::Value *numElements = getVLASize(vla).first;
1830
1831     // Effectively, the multiply by the VLA size is part of the GEP.
1832     // GEP indexes are signed, and scaling an index isn't permitted to
1833     // signed-overflow, so we use the same semantics for our explicit
1834     // multiply.  We suppress this if overflow is not undefined behavior.
1835     if (getLangOpts().isSignedOverflowDefined()) {
1836       Idx = Builder.CreateMul(Idx, numElements);
1837       Address = Builder.CreateGEP(Address, Idx, "arrayidx");
1838     } else {
1839       Idx = Builder.CreateNSWMul(Idx, numElements);
1840       Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx");
1841     }
1842   } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){
1843     // Indexing over an interface, as in "NSString *P; P[4];"
1844     llvm::Value *InterfaceSize =
1845       llvm::ConstantInt::get(Idx->getType(),
1846           getContext().getTypeSizeInChars(OIT).getQuantity());
1847
1848     Idx = Builder.CreateMul(Idx, InterfaceSize);
1849
1850     // The base must be a pointer, which is not an aggregate.  Emit it.
1851     llvm::Value *Base = EmitScalarExpr(E->getBase());
1852     Address = EmitCastToVoidPtr(Base);
1853     Address = Builder.CreateGEP(Address, Idx, "arrayidx");
1854     Address = Builder.CreateBitCast(Address, Base->getType());
1855   } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
1856     // If this is A[i] where A is an array, the frontend will have decayed the
1857     // base to be a ArrayToPointerDecay implicit cast.  While correct, it is
1858     // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a
1859     // "gep x, i" here.  Emit one "gep A, 0, i".
1860     assert(Array->getType()->isArrayType() &&
1861            "Array to pointer decay must have array source type!");
1862     LValue ArrayLV = EmitLValue(Array);
1863     llvm::Value *ArrayPtr = ArrayLV.getAddress();
1864     llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0);
1865     llvm::Value *Args[] = { Zero, Idx };
1866
1867     // Propagate the alignment from the array itself to the result.
1868     ArrayAlignment = ArrayLV.getAlignment();
1869
1870     if (getContext().getLangOpts().isSignedOverflowDefined())
1871       Address = Builder.CreateGEP(ArrayPtr, Args, "arrayidx");
1872     else
1873       Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, "arrayidx");
1874   } else {
1875     // The base must be a pointer, which is not an aggregate.  Emit it.
1876     llvm::Value *Base = EmitScalarExpr(E->getBase());
1877     if (getContext().getLangOpts().isSignedOverflowDefined())
1878       Address = Builder.CreateGEP(Base, Idx, "arrayidx");
1879     else
1880       Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
1881   }
1882
1883   QualType T = E->getBase()->getType()->getPointeeType();
1884   assert(!T.isNull() &&
1885          "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type");
1886
1887
1888   // Limit the alignment to that of the result type.
1889   LValue LV;
1890   if (!ArrayAlignment.isZero()) {
1891     CharUnits Align = getContext().getTypeAlignInChars(T);
1892     ArrayAlignment = std::min(Align, ArrayAlignment);
1893     LV = MakeAddrLValue(Address, T, ArrayAlignment);
1894   } else {
1895     LV = MakeNaturalAlignAddrLValue(Address, T);
1896   }
1897
1898   LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace());
1899
1900   if (getContext().getLangOpts().ObjC1 &&
1901       getContext().getLangOpts().getGC() != LangOptions::NonGC) {
1902     LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
1903     setObjCGCLValueClass(getContext(), E, LV);
1904   }
1905   return LV;
1906 }
1907
1908 static
1909 llvm::Constant *GenerateConstantVector(CGBuilderTy &Builder,
1910                                        SmallVector<unsigned, 4> &Elts) {
1911   SmallVector<llvm::Constant*, 4> CElts;
1912   for (unsigned i = 0, e = Elts.size(); i != e; ++i)
1913     CElts.push_back(Builder.getInt32(Elts[i]));
1914
1915   return llvm::ConstantVector::get(CElts);
1916 }
1917
1918 LValue CodeGenFunction::
1919 EmitExtVectorElementExpr(const ExtVectorElementExpr *E) {
1920   // Emit the base vector as an l-value.
1921   LValue Base;
1922
1923   // ExtVectorElementExpr's base can either be a vector or pointer to vector.
1924   if (E->isArrow()) {
1925     // If it is a pointer to a vector, emit the address and form an lvalue with
1926     // it.
1927     llvm::Value *Ptr = EmitScalarExpr(E->getBase());
1928     const PointerType *PT = E->getBase()->getType()->getAs<PointerType>();
1929     Base = MakeAddrLValue(Ptr, PT->getPointeeType());
1930     Base.getQuals().removeObjCGCAttr();
1931   } else if (E->getBase()->isGLValue()) {
1932     // Otherwise, if the base is an lvalue ( as in the case of foo.x.x),
1933     // emit the base as an lvalue.
1934     assert(E->getBase()->getType()->isVectorType());
1935     Base = EmitLValue(E->getBase());
1936   } else {
1937     // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such.
1938     assert(E->getBase()->getType()->isVectorType() &&
1939            "Result must be a vector");
1940     llvm::Value *Vec = EmitScalarExpr(E->getBase());
1941
1942     // Store the vector to memory (because LValue wants an address).
1943     llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType());
1944     Builder.CreateStore(Vec, VecMem);
1945     Base = MakeAddrLValue(VecMem, E->getBase()->getType());
1946   }
1947
1948   QualType type =
1949     E->getType().withCVRQualifiers(Base.getQuals().getCVRQualifiers());
1950
1951   // Encode the element access list into a vector of unsigned indices.
1952   SmallVector<unsigned, 4> Indices;
1953   E->getEncodedElementAccess(Indices);
1954
1955   if (Base.isSimple()) {
1956     llvm::Constant *CV = GenerateConstantVector(Builder, Indices);
1957     return LValue::MakeExtVectorElt(Base.getAddress(), CV, type,
1958                                     Base.getAlignment());
1959   }
1960   assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!");
1961
1962   llvm::Constant *BaseElts = Base.getExtVectorElts();
1963   SmallVector<llvm::Constant *, 4> CElts;
1964
1965   for (unsigned i = 0, e = Indices.size(); i != e; ++i)
1966     CElts.push_back(BaseElts->getAggregateElement(Indices[i]));
1967   llvm::Constant *CV = llvm::ConstantVector::get(CElts);
1968   return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, type,
1969                                   Base.getAlignment());
1970 }
1971
1972 LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
1973   Expr *BaseExpr = E->getBase();
1974
1975   // If this is s.x, emit s as an lvalue.  If it is s->x, emit s as a scalar.
1976   LValue BaseLV;
1977   if (E->isArrow())
1978     BaseLV = MakeNaturalAlignAddrLValue(EmitScalarExpr(BaseExpr),
1979                                         BaseExpr->getType()->getPointeeType());
1980   else
1981     BaseLV = EmitLValue(BaseExpr);
1982
1983   NamedDecl *ND = E->getMemberDecl();
1984   if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) {
1985     LValue LV = EmitLValueForField(BaseLV, Field);
1986     setObjCGCLValueClass(getContext(), E, LV);
1987     return LV;
1988   }
1989
1990   if (VarDecl *VD = dyn_cast<VarDecl>(ND))
1991     return EmitGlobalVarDeclLValue(*this, E, VD);
1992
1993   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
1994     return EmitFunctionDeclLValue(*this, E, FD);
1995
1996   llvm_unreachable("Unhandled member declaration!");
1997 }
1998
1999 LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value *BaseValue,
2000                                               const FieldDecl *Field,
2001                                               unsigned CVRQualifiers) {
2002   const CGRecordLayout &RL =
2003     CGM.getTypes().getCGRecordLayout(Field->getParent());
2004   const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field);
2005   return LValue::MakeBitfield(BaseValue, Info,
2006                           Field->getType().withCVRQualifiers(CVRQualifiers));
2007 }
2008
2009 /// EmitLValueForAnonRecordField - Given that the field is a member of
2010 /// an anonymous struct or union buried inside a record, and given
2011 /// that the base value is a pointer to the enclosing record, derive
2012 /// an lvalue for the ultimate field.
2013 LValue CodeGenFunction::EmitLValueForAnonRecordField(llvm::Value *BaseValue,
2014                                              const IndirectFieldDecl *Field,
2015                                                      unsigned CVRQualifiers) {
2016   IndirectFieldDecl::chain_iterator I = Field->chain_begin(),
2017     IEnd = Field->chain_end();
2018   while (true) {
2019     QualType RecordTy =
2020         getContext().getTypeDeclType(cast<FieldDecl>(*I)->getParent());
2021     LValue LV = EmitLValueForField(MakeAddrLValue(BaseValue, RecordTy),
2022                                    cast<FieldDecl>(*I));
2023     if (++I == IEnd) return LV;
2024
2025     assert(LV.isSimple());
2026     BaseValue = LV.getAddress();
2027     CVRQualifiers |= LV.getVRQualifiers();
2028   }
2029 }
2030
2031 LValue CodeGenFunction::EmitLValueForField(LValue base,
2032                                            const FieldDecl *field) {
2033   if (field->isBitField())
2034     return EmitLValueForBitfield(base.getAddress(), field,
2035                                  base.getVRQualifiers());
2036
2037   const RecordDecl *rec = field->getParent();
2038   QualType type = field->getType();
2039   CharUnits alignment = getContext().getDeclAlign(field);
2040
2041   // FIXME: It should be impossible to have an LValue without alignment for a
2042   // complete type.
2043   if (!base.getAlignment().isZero())
2044     alignment = std::min(alignment, base.getAlignment());
2045
2046   bool mayAlias = rec->hasAttr<MayAliasAttr>();
2047
2048   llvm::Value *addr = base.getAddress();
2049   unsigned cvr = base.getVRQualifiers();
2050   if (rec->isUnion()) {
2051     // For unions, there is no pointer adjustment.
2052     assert(!type->isReferenceType() && "union has reference member");
2053   } else {
2054     // For structs, we GEP to the field that the record layout suggests.
2055     unsigned idx = CGM.getTypes().getCGRecordLayout(rec).getLLVMFieldNo(field);
2056     addr = Builder.CreateStructGEP(addr, idx, field->getName());
2057
2058     // If this is a reference field, load the reference right now.
2059     if (const ReferenceType *refType = type->getAs<ReferenceType>()) {
2060       llvm::LoadInst *load = Builder.CreateLoad(addr, "ref");
2061       if (cvr & Qualifiers::Volatile) load->setVolatile(true);
2062       load->setAlignment(alignment.getQuantity());
2063
2064       if (CGM.shouldUseTBAA()) {
2065         llvm::MDNode *tbaa;
2066         if (mayAlias)
2067           tbaa = CGM.getTBAAInfo(getContext().CharTy);
2068         else
2069           tbaa = CGM.getTBAAInfo(type);
2070         CGM.DecorateInstruction(load, tbaa);
2071       }
2072
2073       addr = load;
2074       mayAlias = false;
2075       type = refType->getPointeeType();
2076       if (type->isIncompleteType())
2077         alignment = CharUnits();
2078       else
2079         alignment = getContext().getTypeAlignInChars(type);
2080       cvr = 0; // qualifiers don't recursively apply to referencee
2081     }
2082   }
2083
2084   // Make sure that the address is pointing to the right type.  This is critical
2085   // for both unions and structs.  A union needs a bitcast, a struct element
2086   // will need a bitcast if the LLVM type laid out doesn't match the desired
2087   // type.
2088   addr = EmitBitCastOfLValueToProperType(*this, addr,
2089                                          CGM.getTypes().ConvertTypeForMem(type),
2090                                          field->getName());
2091
2092   if (field->hasAttr<AnnotateAttr>())
2093     addr = EmitFieldAnnotations(field, addr);
2094
2095   LValue LV = MakeAddrLValue(addr, type, alignment);
2096   LV.getQuals().addCVRQualifiers(cvr);
2097
2098   // __weak attribute on a field is ignored.
2099   if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak)
2100     LV.getQuals().removeObjCGCAttr();
2101
2102   // Fields of may_alias structs act like 'char' for TBAA purposes.
2103   // FIXME: this should get propagated down through anonymous structs
2104   // and unions.
2105   if (mayAlias && LV.getTBAAInfo())
2106     LV.setTBAAInfo(CGM.getTBAAInfo(getContext().CharTy));
2107
2108   return LV;
2109 }
2110
2111 LValue
2112 CodeGenFunction::EmitLValueForFieldInitialization(LValue Base,
2113                                                   const FieldDecl *Field) {
2114   QualType FieldType = Field->getType();
2115
2116   if (!FieldType->isReferenceType())
2117     return EmitLValueForField(Base, Field);
2118
2119   const CGRecordLayout &RL =
2120     CGM.getTypes().getCGRecordLayout(Field->getParent());
2121   unsigned idx = RL.getLLVMFieldNo(Field);
2122   llvm::Value *V = Builder.CreateStructGEP(Base.getAddress(), idx);
2123   assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
2124
2125   // Make sure that the address is pointing to the right type.  This is critical
2126   // for both unions and structs.  A union needs a bitcast, a struct element
2127   // will need a bitcast if the LLVM type laid out doesn't match the desired
2128   // type.
2129   llvm::Type *llvmType = ConvertTypeForMem(FieldType);
2130   V = EmitBitCastOfLValueToProperType(*this, V, llvmType, Field->getName());
2131
2132   CharUnits Alignment = getContext().getDeclAlign(Field);
2133
2134   // FIXME: It should be impossible to have an LValue without alignment for a
2135   // complete type.
2136   if (!Base.getAlignment().isZero())
2137     Alignment = std::min(Alignment, Base.getAlignment());
2138
2139   return MakeAddrLValue(V, FieldType, Alignment);
2140 }
2141
2142 LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){
2143   if (E->isFileScope()) {
2144     llvm::Value *GlobalPtr = CGM.GetAddrOfConstantCompoundLiteral(E);
2145     return MakeAddrLValue(GlobalPtr, E->getType());
2146   }
2147
2148   llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral");
2149   const Expr *InitExpr = E->getInitializer();
2150   LValue Result = MakeAddrLValue(DeclPtr, E->getType());
2151
2152   EmitAnyExprToMem(InitExpr, DeclPtr, E->getType().getQualifiers(),
2153                    /*Init*/ true);
2154
2155   return Result;
2156 }
2157
2158 LValue CodeGenFunction::
2159 EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) {
2160   if (!expr->isGLValue()) {
2161     // ?: here should be an aggregate.
2162     assert((hasAggregateLLVMType(expr->getType()) &&
2163             !expr->getType()->isAnyComplexType()) &&
2164            "Unexpected conditional operator!");
2165     return EmitAggExprToLValue(expr);
2166   }
2167
2168   OpaqueValueMapping binding(*this, expr);
2169
2170   const Expr *condExpr = expr->getCond();
2171   bool CondExprBool;
2172   if (ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
2173     const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr();
2174     if (!CondExprBool) std::swap(live, dead);
2175
2176     if (!ContainsLabel(dead))
2177       return EmitLValue(live);
2178   }
2179
2180   llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true");
2181   llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false");
2182   llvm::BasicBlock *contBlock = createBasicBlock("cond.end");
2183
2184   ConditionalEvaluation eval(*this);
2185   EmitBranchOnBoolExpr(condExpr, lhsBlock, rhsBlock);
2186
2187   // Any temporaries created here are conditional.
2188   EmitBlock(lhsBlock);
2189   eval.begin(*this);
2190   LValue lhs = EmitLValue(expr->getTrueExpr());
2191   eval.end(*this);
2192
2193   if (!lhs.isSimple())
2194     return EmitUnsupportedLValue(expr, "conditional operator");
2195
2196   lhsBlock = Builder.GetInsertBlock();
2197   Builder.CreateBr(contBlock);
2198
2199   // Any temporaries created here are conditional.
2200   EmitBlock(rhsBlock);
2201   eval.begin(*this);
2202   LValue rhs = EmitLValue(expr->getFalseExpr());
2203   eval.end(*this);
2204   if (!rhs.isSimple())
2205     return EmitUnsupportedLValue(expr, "conditional operator");
2206   rhsBlock = Builder.GetInsertBlock();
2207
2208   EmitBlock(contBlock);
2209
2210   llvm::PHINode *phi = Builder.CreatePHI(lhs.getAddress()->getType(), 2,
2211                                          "cond-lvalue");
2212   phi->addIncoming(lhs.getAddress(), lhsBlock);
2213   phi->addIncoming(rhs.getAddress(), rhsBlock);
2214   return MakeAddrLValue(phi, expr->getType());
2215 }
2216
2217 /// EmitCastLValue - Casts are never lvalues unless that cast is a dynamic_cast.
2218 /// If the cast is a dynamic_cast, we can have the usual lvalue result,
2219 /// otherwise if a cast is needed by the code generator in an lvalue context,
2220 /// then it must mean that we need the address of an aggregate in order to
2221 /// access one of its fields.  This can happen for all the reasons that casts
2222 /// are permitted with aggregate result, including noop aggregate casts, and
2223 /// cast from scalar to union.
2224 LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
2225   switch (E->getCastKind()) {
2226   case CK_ToVoid:
2227     return EmitUnsupportedLValue(E, "unexpected cast lvalue");
2228
2229   case CK_Dependent:
2230     llvm_unreachable("dependent cast kind in IR gen!");
2231
2232   // These two casts are currently treated as no-ops, although they could
2233   // potentially be real operations depending on the target's ABI.
2234   case CK_NonAtomicToAtomic:
2235   case CK_AtomicToNonAtomic:
2236
2237   case CK_NoOp:
2238   case CK_LValueToRValue:
2239     if (!E->getSubExpr()->Classify(getContext()).isPRValue()
2240         || E->getType()->isRecordType())
2241       return EmitLValue(E->getSubExpr());
2242     // Fall through to synthesize a temporary.
2243
2244   case CK_BitCast:
2245   case CK_ArrayToPointerDecay:
2246   case CK_FunctionToPointerDecay:
2247   case CK_NullToMemberPointer:
2248   case CK_NullToPointer:
2249   case CK_IntegralToPointer:
2250   case CK_PointerToIntegral:
2251   case CK_PointerToBoolean:
2252   case CK_VectorSplat:
2253   case CK_IntegralCast:
2254   case CK_IntegralToBoolean:
2255   case CK_IntegralToFloating:
2256   case CK_FloatingToIntegral:
2257   case CK_FloatingToBoolean:
2258   case CK_FloatingCast:
2259   case CK_FloatingRealToComplex:
2260   case CK_FloatingComplexToReal:
2261   case CK_FloatingComplexToBoolean:
2262   case CK_FloatingComplexCast:
2263   case CK_FloatingComplexToIntegralComplex:
2264   case CK_IntegralRealToComplex:
2265   case CK_IntegralComplexToReal:
2266   case CK_IntegralComplexToBoolean:
2267   case CK_IntegralComplexCast:
2268   case CK_IntegralComplexToFloatingComplex:
2269   case CK_DerivedToBaseMemberPointer:
2270   case CK_BaseToDerivedMemberPointer:
2271   case CK_MemberPointerToBoolean:
2272   case CK_ReinterpretMemberPointer:
2273   case CK_AnyPointerToBlockPointerCast:
2274   case CK_ARCProduceObject:
2275   case CK_ARCConsumeObject:
2276   case CK_ARCReclaimReturnedObject:
2277   case CK_ARCExtendBlockObject:
2278   case CK_CopyAndAutoreleaseBlockObject: {
2279     // These casts only produce lvalues when we're binding a reference to a
2280     // temporary realized from a (converted) pure rvalue. Emit the expression
2281     // as a value, copy it into a temporary, and return an lvalue referring to
2282     // that temporary.
2283     llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp");
2284     EmitAnyExprToMem(E, V, E->getType().getQualifiers(), false);
2285     return MakeAddrLValue(V, E->getType());
2286   }
2287
2288   case CK_Dynamic: {
2289     LValue LV = EmitLValue(E->getSubExpr());
2290     llvm::Value *V = LV.getAddress();
2291     const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E);
2292     return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType());
2293   }
2294
2295   case CK_ConstructorConversion:
2296   case CK_UserDefinedConversion:
2297   case CK_CPointerToObjCPointerCast:
2298   case CK_BlockPointerToObjCPointerCast:
2299     return EmitLValue(E->getSubExpr());
2300
2301   case CK_UncheckedDerivedToBase:
2302   case CK_DerivedToBase: {
2303     const RecordType *DerivedClassTy =
2304       E->getSubExpr()->getType()->getAs<RecordType>();
2305     CXXRecordDecl *DerivedClassDecl =
2306       cast<CXXRecordDecl>(DerivedClassTy->getDecl());
2307
2308     LValue LV = EmitLValue(E->getSubExpr());
2309     llvm::Value *This = LV.getAddress();
2310
2311     // Perform the derived-to-base conversion
2312     llvm::Value *Base =
2313       GetAddressOfBaseClass(This, DerivedClassDecl,
2314                             E->path_begin(), E->path_end(),
2315                             /*NullCheckValue=*/false);
2316
2317     return MakeAddrLValue(Base, E->getType());
2318   }
2319   case CK_ToUnion:
2320     return EmitAggExprToLValue(E);
2321   case CK_BaseToDerived: {
2322     const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>();
2323     CXXRecordDecl *DerivedClassDecl =
2324       cast<CXXRecordDecl>(DerivedClassTy->getDecl());
2325
2326     LValue LV = EmitLValue(E->getSubExpr());
2327
2328     // Perform the base-to-derived conversion
2329     llvm::Value *Derived =
2330       GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl,
2331                                E->path_begin(), E->path_end(),
2332                                /*NullCheckValue=*/false);
2333
2334     return MakeAddrLValue(Derived, E->getType());
2335   }
2336   case CK_LValueBitCast: {
2337     // This must be a reinterpret_cast (or c-style equivalent).
2338     const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E);
2339
2340     LValue LV = EmitLValue(E->getSubExpr());
2341     llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2342                                            ConvertType(CE->getTypeAsWritten()));
2343     return MakeAddrLValue(V, E->getType());
2344   }
2345   case CK_ObjCObjectLValueCast: {
2346     LValue LV = EmitLValue(E->getSubExpr());
2347     QualType ToType = getContext().getLValueReferenceType(E->getType());
2348     llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2349                                            ConvertType(ToType));
2350     return MakeAddrLValue(V, E->getType());
2351   }
2352   }
2353
2354   llvm_unreachable("Unhandled lvalue cast kind?");
2355 }
2356
2357 LValue CodeGenFunction::EmitNullInitializationLValue(
2358                                               const CXXScalarValueInitExpr *E) {
2359   QualType Ty = E->getType();
2360   LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty);
2361   EmitNullInitialization(LV.getAddress(), Ty);
2362   return LV;
2363 }
2364
2365 LValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) {
2366   assert(OpaqueValueMappingData::shouldBindAsLValue(e));
2367   return getOpaqueLValueMapping(e);
2368 }
2369
2370 LValue CodeGenFunction::EmitMaterializeTemporaryExpr(
2371                                            const MaterializeTemporaryExpr *E) {
2372   RValue RV = EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
2373   return MakeAddrLValue(RV.getScalarVal(), E->getType());
2374 }
2375
2376 RValue CodeGenFunction::EmitRValueForField(LValue LV,
2377                                            const FieldDecl *FD) {
2378   QualType FT = FD->getType();
2379   LValue FieldLV = EmitLValueForField(LV, FD);
2380   if (FT->isAnyComplexType())
2381     return RValue::getComplex(
2382         LoadComplexFromAddr(FieldLV.getAddress(),
2383                             FieldLV.isVolatileQualified()));
2384   else if (CodeGenFunction::hasAggregateLLVMType(FT))
2385     return FieldLV.asAggregateRValue();
2386
2387   return EmitLoadOfLValue(FieldLV);
2388 }
2389
2390 //===--------------------------------------------------------------------===//
2391 //                             Expression Emission
2392 //===--------------------------------------------------------------------===//
2393
2394 RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
2395                                      ReturnValueSlot ReturnValue) {
2396   if (CGDebugInfo *DI = getDebugInfo())
2397     DI->EmitLocation(Builder, E->getLocStart());
2398
2399   // Builtins never have block type.
2400   if (E->getCallee()->getType()->isBlockPointerType())
2401     return EmitBlockCallExpr(E, ReturnValue);
2402
2403   if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E))
2404     return EmitCXXMemberCallExpr(CE, ReturnValue);
2405
2406   if (const CUDAKernelCallExpr *CE = dyn_cast<CUDAKernelCallExpr>(E))
2407     return EmitCUDAKernelCallExpr(CE, ReturnValue);
2408
2409   const Decl *TargetDecl = E->getCalleeDecl();
2410   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
2411     if (unsigned builtinID = FD->getBuiltinID())
2412       return EmitBuiltinExpr(FD, builtinID, E);
2413   }
2414
2415   if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E))
2416     if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl))
2417       return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue);
2418
2419   if (const CXXPseudoDestructorExpr *PseudoDtor
2420           = dyn_cast<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) {
2421     QualType DestroyedType = PseudoDtor->getDestroyedType();
2422     if (getContext().getLangOpts().ObjCAutoRefCount &&
2423         DestroyedType->isObjCLifetimeType() &&
2424         (DestroyedType.getObjCLifetime() == Qualifiers::OCL_Strong ||
2425          DestroyedType.getObjCLifetime() == Qualifiers::OCL_Weak)) {
2426       // Automatic Reference Counting:
2427       //   If the pseudo-expression names a retainable object with weak or
2428       //   strong lifetime, the object shall be released.
2429       Expr *BaseExpr = PseudoDtor->getBase();
2430       llvm::Value *BaseValue = NULL;
2431       Qualifiers BaseQuals;
2432
2433       // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
2434       if (PseudoDtor->isArrow()) {
2435         BaseValue = EmitScalarExpr(BaseExpr);
2436         const PointerType *PTy = BaseExpr->getType()->getAs<PointerType>();
2437         BaseQuals = PTy->getPointeeType().getQualifiers();
2438       } else {
2439         LValue BaseLV = EmitLValue(BaseExpr);
2440         BaseValue = BaseLV.getAddress();
2441         QualType BaseTy = BaseExpr->getType();
2442         BaseQuals = BaseTy.getQualifiers();
2443       }
2444
2445       switch (PseudoDtor->getDestroyedType().getObjCLifetime()) {
2446       case Qualifiers::OCL_None:
2447       case Qualifiers::OCL_ExplicitNone:
2448       case Qualifiers::OCL_Autoreleasing:
2449         break;
2450
2451       case Qualifiers::OCL_Strong:
2452         EmitARCRelease(Builder.CreateLoad(BaseValue,
2453                           PseudoDtor->getDestroyedType().isVolatileQualified()),
2454                        /*precise*/ true);
2455         break;
2456
2457       case Qualifiers::OCL_Weak:
2458         EmitARCDestroyWeak(BaseValue);
2459         break;
2460       }
2461     } else {
2462       // C++ [expr.pseudo]p1:
2463       //   The result shall only be used as the operand for the function call
2464       //   operator (), and the result of such a call has type void. The only
2465       //   effect is the evaluation of the postfix-expression before the dot or
2466       //   arrow.
2467       EmitScalarExpr(E->getCallee());
2468     }
2469
2470     return RValue::get(0);
2471   }
2472
2473   llvm::Value *Callee = EmitScalarExpr(E->getCallee());
2474   return EmitCall(E->getCallee()->getType(), Callee, ReturnValue,
2475                   E->arg_begin(), E->arg_end(), TargetDecl);
2476 }
2477
2478 LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
2479   // Comma expressions just emit their LHS then their RHS as an l-value.
2480   if (E->getOpcode() == BO_Comma) {
2481     EmitIgnoredExpr(E->getLHS());
2482     EnsureInsertPoint();
2483     return EmitLValue(E->getRHS());
2484   }
2485
2486   if (E->getOpcode() == BO_PtrMemD ||
2487       E->getOpcode() == BO_PtrMemI)
2488     return EmitPointerToDataMemberBinaryExpr(E);
2489
2490   assert(E->getOpcode() == BO_Assign && "unexpected binary l-value");
2491
2492   // Note that in all of these cases, __block variables need the RHS
2493   // evaluated first just in case the variable gets moved by the RHS.
2494
2495   if (!hasAggregateLLVMType(E->getType())) {
2496     switch (E->getLHS()->getType().getObjCLifetime()) {
2497     case Qualifiers::OCL_Strong:
2498       return EmitARCStoreStrong(E, /*ignored*/ false).first;
2499
2500     case Qualifiers::OCL_Autoreleasing:
2501       return EmitARCStoreAutoreleasing(E).first;
2502
2503     // No reason to do any of these differently.
2504     case Qualifiers::OCL_None:
2505     case Qualifiers::OCL_ExplicitNone:
2506     case Qualifiers::OCL_Weak:
2507       break;
2508     }
2509
2510     RValue RV = EmitAnyExpr(E->getRHS());
2511     LValue LV = EmitLValue(E->getLHS());
2512     EmitStoreThroughLValue(RV, LV);
2513     return LV;
2514   }
2515
2516   if (E->getType()->isAnyComplexType())
2517     return EmitComplexAssignmentLValue(E);
2518
2519   return EmitAggExprToLValue(E);
2520 }
2521
2522 LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
2523   RValue RV = EmitCallExpr(E);
2524
2525   if (!RV.isScalar())
2526     return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
2527
2528   assert(E->getCallReturnType()->isReferenceType() &&
2529          "Can't have a scalar return unless the return type is a "
2530          "reference type!");
2531
2532   return MakeAddrLValue(RV.getScalarVal(), E->getType());
2533 }
2534
2535 LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
2536   // FIXME: This shouldn't require another copy.
2537   return EmitAggExprToLValue(E);
2538 }
2539
2540 LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
2541   assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor()
2542          && "binding l-value to type which needs a temporary");
2543   AggValueSlot Slot = CreateAggTemp(E->getType());
2544   EmitCXXConstructExpr(E, Slot);
2545   return MakeAddrLValue(Slot.getAddr(), E->getType());
2546 }
2547
2548 LValue
2549 CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) {
2550   return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType());
2551 }
2552
2553 LValue
2554 CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) {
2555   AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
2556   Slot.setExternallyDestructed();
2557   EmitAggExpr(E->getSubExpr(), Slot);
2558   EmitCXXTemporary(E->getTemporary(), E->getType(), Slot.getAddr());
2559   return MakeAddrLValue(Slot.getAddr(), E->getType());
2560 }
2561
2562 LValue
2563 CodeGenFunction::EmitLambdaLValue(const LambdaExpr *E) {
2564   AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
2565   EmitLambdaExpr(E, Slot);
2566   return MakeAddrLValue(Slot.getAddr(), E->getType());
2567 }
2568
2569 LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
2570   RValue RV = EmitObjCMessageExpr(E);
2571
2572   if (!RV.isScalar())
2573     return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
2574
2575   assert(E->getMethodDecl()->getResultType()->isReferenceType() &&
2576          "Can't have a scalar return unless the return type is a "
2577          "reference type!");
2578
2579   return MakeAddrLValue(RV.getScalarVal(), E->getType());
2580 }
2581
2582 LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) {
2583   llvm::Value *V =
2584     CGM.getObjCRuntime().GetSelector(Builder, E->getSelector(), true);
2585   return MakeAddrLValue(V, E->getType());
2586 }
2587
2588 llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface,
2589                                              const ObjCIvarDecl *Ivar) {
2590   return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar);
2591 }
2592
2593 LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
2594                                           llvm::Value *BaseValue,
2595                                           const ObjCIvarDecl *Ivar,
2596                                           unsigned CVRQualifiers) {
2597   return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue,
2598                                                    Ivar, CVRQualifiers);
2599 }
2600
2601 LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
2602   // FIXME: A lot of the code below could be shared with EmitMemberExpr.
2603   llvm::Value *BaseValue = 0;
2604   const Expr *BaseExpr = E->getBase();
2605   Qualifiers BaseQuals;
2606   QualType ObjectTy;
2607   if (E->isArrow()) {
2608     BaseValue = EmitScalarExpr(BaseExpr);
2609     ObjectTy = BaseExpr->getType()->getPointeeType();
2610     BaseQuals = ObjectTy.getQualifiers();
2611   } else {
2612     LValue BaseLV = EmitLValue(BaseExpr);
2613     // FIXME: this isn't right for bitfields.
2614     BaseValue = BaseLV.getAddress();
2615     ObjectTy = BaseExpr->getType();
2616     BaseQuals = ObjectTy.getQualifiers();
2617   }
2618
2619   LValue LV =
2620     EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(),
2621                       BaseQuals.getCVRQualifiers());
2622   setObjCGCLValueClass(getContext(), E, LV);
2623   return LV;
2624 }
2625
2626 LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
2627   // Can only get l-value for message expression returning aggregate type
2628   RValue RV = EmitAnyExprToTemp(E);
2629   return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
2630 }
2631
2632 RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee,
2633                                  ReturnValueSlot ReturnValue,
2634                                  CallExpr::const_arg_iterator ArgBeg,
2635                                  CallExpr::const_arg_iterator ArgEnd,
2636                                  const Decl *TargetDecl) {
2637   // Get the actual function type. The callee type will always be a pointer to
2638   // function type or a block pointer type.
2639   assert(CalleeType->isFunctionPointerType() &&
2640          "Call must have function pointer type!");
2641
2642   CalleeType = getContext().getCanonicalType(CalleeType);
2643
2644   const FunctionType *FnType
2645     = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType());
2646
2647   CallArgList Args;
2648   EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
2649
2650   const CGFunctionInfo &FnInfo =
2651     CGM.getTypes().arrangeFunctionCall(Args, FnType);
2652
2653   // C99 6.5.2.2p6:
2654   //   If the expression that denotes the called function has a type
2655   //   that does not include a prototype, [the default argument
2656   //   promotions are performed]. If the number of arguments does not
2657   //   equal the number of parameters, the behavior is undefined. If
2658   //   the function is defined with a type that includes a prototype,
2659   //   and either the prototype ends with an ellipsis (, ...) or the
2660   //   types of the arguments after promotion are not compatible with
2661   //   the types of the parameters, the behavior is undefined. If the
2662   //   function is defined with a type that does not include a
2663   //   prototype, and the types of the arguments after promotion are
2664   //   not compatible with those of the parameters after promotion,
2665   //   the behavior is undefined [except in some trivial cases].
2666   // That is, in the general case, we should assume that a call
2667   // through an unprototyped function type works like a *non-variadic*
2668   // call.  The way we make this work is to cast to the exact type
2669   // of the promoted arguments.
2670   if (isa<FunctionNoProtoType>(FnType) && !FnInfo.isVariadic()) {
2671     llvm::Type *CalleeTy = getTypes().GetFunctionType(FnInfo);
2672     CalleeTy = CalleeTy->getPointerTo();
2673     Callee = Builder.CreateBitCast(Callee, CalleeTy, "callee.knr.cast");
2674   }
2675
2676   return EmitCall(FnInfo, Callee, ReturnValue, Args, TargetDecl);
2677 }
2678
2679 LValue CodeGenFunction::
2680 EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
2681   llvm::Value *BaseV;
2682   if (E->getOpcode() == BO_PtrMemI)
2683     BaseV = EmitScalarExpr(E->getLHS());
2684   else
2685     BaseV = EmitLValue(E->getLHS()).getAddress();
2686
2687   llvm::Value *OffsetV = EmitScalarExpr(E->getRHS());
2688
2689   const MemberPointerType *MPT
2690     = E->getRHS()->getType()->getAs<MemberPointerType>();
2691
2692   llvm::Value *AddV =
2693     CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT);
2694
2695   return MakeAddrLValue(AddV, MPT->getPointeeType());
2696 }
2697
2698 static void
2699 EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest,
2700              llvm::Value *Ptr, llvm::Value *Val1, llvm::Value *Val2,
2701              uint64_t Size, unsigned Align, llvm::AtomicOrdering Order) {
2702   llvm::AtomicRMWInst::BinOp Op = llvm::AtomicRMWInst::Add;
2703   llvm::Instruction::BinaryOps PostOp = (llvm::Instruction::BinaryOps)0;
2704
2705   switch (E->getOp()) {
2706   case AtomicExpr::AO__c11_atomic_init:
2707     llvm_unreachable("Already handled!");
2708
2709   case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
2710   case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
2711   case AtomicExpr::AO__atomic_compare_exchange:
2712   case AtomicExpr::AO__atomic_compare_exchange_n: {
2713     // Note that cmpxchg only supports specifying one ordering and
2714     // doesn't support weak cmpxchg, at least at the moment.
2715     llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2716     LoadVal1->setAlignment(Align);
2717     llvm::LoadInst *LoadVal2 = CGF.Builder.CreateLoad(Val2);
2718     LoadVal2->setAlignment(Align);
2719     llvm::AtomicCmpXchgInst *CXI =
2720         CGF.Builder.CreateAtomicCmpXchg(Ptr, LoadVal1, LoadVal2, Order);
2721     CXI->setVolatile(E->isVolatile());
2722     llvm::StoreInst *StoreVal1 = CGF.Builder.CreateStore(CXI, Val1);
2723     StoreVal1->setAlignment(Align);
2724     llvm::Value *Cmp = CGF.Builder.CreateICmpEQ(CXI, LoadVal1);
2725     CGF.EmitStoreOfScalar(Cmp, CGF.MakeAddrLValue(Dest, E->getType()));
2726     return;
2727   }
2728
2729   case AtomicExpr::AO__c11_atomic_load:
2730   case AtomicExpr::AO__atomic_load_n:
2731   case AtomicExpr::AO__atomic_load: {
2732     llvm::LoadInst *Load = CGF.Builder.CreateLoad(Ptr);
2733     Load->setAtomic(Order);
2734     Load->setAlignment(Size);
2735     Load->setVolatile(E->isVolatile());
2736     llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(Load, Dest);
2737     StoreDest->setAlignment(Align);
2738     return;
2739   }
2740
2741   case AtomicExpr::AO__c11_atomic_store:
2742   case AtomicExpr::AO__atomic_store:
2743   case AtomicExpr::AO__atomic_store_n: {
2744     assert(!Dest && "Store does not return a value");
2745     llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2746     LoadVal1->setAlignment(Align);
2747     llvm::StoreInst *Store = CGF.Builder.CreateStore(LoadVal1, Ptr);
2748     Store->setAtomic(Order);
2749     Store->setAlignment(Size);
2750     Store->setVolatile(E->isVolatile());
2751     return;
2752   }
2753
2754   case AtomicExpr::AO__c11_atomic_exchange:
2755   case AtomicExpr::AO__atomic_exchange_n:
2756   case AtomicExpr::AO__atomic_exchange:
2757     Op = llvm::AtomicRMWInst::Xchg;
2758     break;
2759
2760   case AtomicExpr::AO__atomic_add_fetch:
2761     PostOp = llvm::Instruction::Add;
2762     // Fall through.
2763   case AtomicExpr::AO__c11_atomic_fetch_add:
2764   case AtomicExpr::AO__atomic_fetch_add:
2765     Op = llvm::AtomicRMWInst::Add;
2766     break;
2767
2768   case AtomicExpr::AO__atomic_sub_fetch:
2769     PostOp = llvm::Instruction::Sub;
2770     // Fall through.
2771   case AtomicExpr::AO__c11_atomic_fetch_sub:
2772   case AtomicExpr::AO__atomic_fetch_sub:
2773     Op = llvm::AtomicRMWInst::Sub;
2774     break;
2775
2776   case AtomicExpr::AO__atomic_and_fetch:
2777     PostOp = llvm::Instruction::And;
2778     // Fall through.
2779   case AtomicExpr::AO__c11_atomic_fetch_and:
2780   case AtomicExpr::AO__atomic_fetch_and:
2781     Op = llvm::AtomicRMWInst::And;
2782     break;
2783
2784   case AtomicExpr::AO__atomic_or_fetch:
2785     PostOp = llvm::Instruction::Or;
2786     // Fall through.
2787   case AtomicExpr::AO__c11_atomic_fetch_or:
2788   case AtomicExpr::AO__atomic_fetch_or:
2789     Op = llvm::AtomicRMWInst::Or;
2790     break;
2791
2792   case AtomicExpr::AO__atomic_xor_fetch:
2793     PostOp = llvm::Instruction::Xor;
2794     // Fall through.
2795   case AtomicExpr::AO__c11_atomic_fetch_xor:
2796   case AtomicExpr::AO__atomic_fetch_xor:
2797     Op = llvm::AtomicRMWInst::Xor;
2798     break;
2799
2800   case AtomicExpr::AO__atomic_nand_fetch:
2801     PostOp = llvm::Instruction::And;
2802     // Fall through.
2803   case AtomicExpr::AO__atomic_fetch_nand:
2804     Op = llvm::AtomicRMWInst::Nand;
2805     break;
2806   }
2807
2808   llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2809   LoadVal1->setAlignment(Align);
2810   llvm::AtomicRMWInst *RMWI =
2811       CGF.Builder.CreateAtomicRMW(Op, Ptr, LoadVal1, Order);
2812   RMWI->setVolatile(E->isVolatile());
2813
2814   // For __atomic_*_fetch operations, perform the operation again to
2815   // determine the value which was written.
2816   llvm::Value *Result = RMWI;
2817   if (PostOp)
2818     Result = CGF.Builder.CreateBinOp(PostOp, RMWI, LoadVal1);
2819   if (E->getOp() == AtomicExpr::AO__atomic_nand_fetch)
2820     Result = CGF.Builder.CreateNot(Result);
2821   llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(Result, Dest);
2822   StoreDest->setAlignment(Align);
2823 }
2824
2825 // This function emits any expression (scalar, complex, or aggregate)
2826 // into a temporary alloca.
2827 static llvm::Value *
2828 EmitValToTemp(CodeGenFunction &CGF, Expr *E) {
2829   llvm::Value *DeclPtr = CGF.CreateMemTemp(E->getType(), ".atomictmp");
2830   CGF.EmitAnyExprToMem(E, DeclPtr, E->getType().getQualifiers(),
2831                        /*Init*/ true);
2832   return DeclPtr;
2833 }
2834
2835 static RValue ConvertTempToRValue(CodeGenFunction &CGF, QualType Ty,
2836                                   llvm::Value *Dest) {
2837   if (Ty->isAnyComplexType())
2838     return RValue::getComplex(CGF.LoadComplexFromAddr(Dest, false));
2839   if (CGF.hasAggregateLLVMType(Ty))
2840     return RValue::getAggregate(Dest);
2841   return RValue::get(CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(Dest, Ty)));
2842 }
2843
2844 RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
2845   QualType AtomicTy = E->getPtr()->getType()->getPointeeType();
2846   QualType MemTy = AtomicTy;
2847   if (const AtomicType *AT = AtomicTy->getAs<AtomicType>())
2848     MemTy = AT->getValueType();
2849   CharUnits sizeChars = getContext().getTypeSizeInChars(AtomicTy);
2850   uint64_t Size = sizeChars.getQuantity();
2851   CharUnits alignChars = getContext().getTypeAlignInChars(AtomicTy);
2852   unsigned Align = alignChars.getQuantity();
2853   unsigned MaxInlineWidth =
2854       getContext().getTargetInfo().getMaxAtomicInlineWidth();
2855   bool UseLibcall = (Size != Align || Size > MaxInlineWidth);
2856
2857
2858
2859   llvm::Value *Ptr, *Order, *OrderFail = 0, *Val1 = 0, *Val2 = 0;
2860   Ptr = EmitScalarExpr(E->getPtr());
2861
2862   if (E->getOp() == AtomicExpr::AO__c11_atomic_init) {
2863     assert(!Dest && "Init does not return a value");
2864     if (!hasAggregateLLVMType(E->getVal1()->getType())) {
2865       QualType PointeeType
2866         = E->getPtr()->getType()->getAs<PointerType>()->getPointeeType();
2867       EmitScalarInit(EmitScalarExpr(E->getVal1()),
2868                      LValue::MakeAddr(Ptr, PointeeType, alignChars,
2869                                       getContext()));
2870     } else if (E->getType()->isAnyComplexType()) {
2871       EmitComplexExprIntoAddr(E->getVal1(), Ptr, E->isVolatile());
2872     } else {
2873       AggValueSlot Slot = AggValueSlot::forAddr(Ptr, alignChars,
2874                                         AtomicTy.getQualifiers(),
2875                                         AggValueSlot::IsNotDestructed,
2876                                         AggValueSlot::DoesNotNeedGCBarriers,
2877                                         AggValueSlot::IsNotAliased);
2878       EmitAggExpr(E->getVal1(), Slot);
2879     }
2880     return RValue::get(0);
2881   }
2882
2883   Order = EmitScalarExpr(E->getOrder());
2884
2885   switch (E->getOp()) {
2886   case AtomicExpr::AO__c11_atomic_init:
2887     llvm_unreachable("Already handled!");
2888
2889   case AtomicExpr::AO__c11_atomic_load:
2890   case AtomicExpr::AO__atomic_load_n:
2891     break;
2892
2893   case AtomicExpr::AO__atomic_load:
2894     Dest = EmitScalarExpr(E->getVal1());
2895     break;
2896
2897   case AtomicExpr::AO__atomic_store:
2898     Val1 = EmitScalarExpr(E->getVal1());
2899     break;
2900
2901   case AtomicExpr::AO__atomic_exchange:
2902     Val1 = EmitScalarExpr(E->getVal1());
2903     Dest = EmitScalarExpr(E->getVal2());
2904     break;
2905
2906   case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
2907   case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
2908   case AtomicExpr::AO__atomic_compare_exchange_n:
2909   case AtomicExpr::AO__atomic_compare_exchange:
2910     Val1 = EmitScalarExpr(E->getVal1());
2911     if (E->getOp() == AtomicExpr::AO__atomic_compare_exchange)
2912       Val2 = EmitScalarExpr(E->getVal2());
2913     else
2914       Val2 = EmitValToTemp(*this, E->getVal2());
2915     OrderFail = EmitScalarExpr(E->getOrderFail());
2916     // Evaluate and discard the 'weak' argument.
2917     if (E->getNumSubExprs() == 6)
2918       EmitScalarExpr(E->getWeak());
2919     break;
2920
2921   case AtomicExpr::AO__c11_atomic_fetch_add:
2922   case AtomicExpr::AO__c11_atomic_fetch_sub:
2923     if (MemTy->isPointerType()) {
2924       // For pointer arithmetic, we're required to do a bit of math:
2925       // adding 1 to an int* is not the same as adding 1 to a uintptr_t.
2926       // ... but only for the C11 builtins. The GNU builtins expect the
2927       // user to multiply by sizeof(T).
2928       QualType Val1Ty = E->getVal1()->getType();
2929       llvm::Value *Val1Scalar = EmitScalarExpr(E->getVal1());
2930       CharUnits PointeeIncAmt =
2931           getContext().getTypeSizeInChars(MemTy->getPointeeType());
2932       Val1Scalar = Builder.CreateMul(Val1Scalar, CGM.getSize(PointeeIncAmt));
2933       Val1 = CreateMemTemp(Val1Ty, ".atomictmp");
2934       EmitStoreOfScalar(Val1Scalar, MakeAddrLValue(Val1, Val1Ty));
2935       break;
2936     }
2937     // Fall through.
2938   case AtomicExpr::AO__atomic_fetch_add:
2939   case AtomicExpr::AO__atomic_fetch_sub:
2940   case AtomicExpr::AO__atomic_add_fetch:
2941   case AtomicExpr::AO__atomic_sub_fetch:
2942   case AtomicExpr::AO__c11_atomic_store:
2943   case AtomicExpr::AO__c11_atomic_exchange:
2944   case AtomicExpr::AO__atomic_store_n:
2945   case AtomicExpr::AO__atomic_exchange_n:
2946   case AtomicExpr::AO__c11_atomic_fetch_and:
2947   case AtomicExpr::AO__c11_atomic_fetch_or:
2948   case AtomicExpr::AO__c11_atomic_fetch_xor:
2949   case AtomicExpr::AO__atomic_fetch_and:
2950   case AtomicExpr::AO__atomic_fetch_or:
2951   case AtomicExpr::AO__atomic_fetch_xor:
2952   case AtomicExpr::AO__atomic_fetch_nand:
2953   case AtomicExpr::AO__atomic_and_fetch:
2954   case AtomicExpr::AO__atomic_or_fetch:
2955   case AtomicExpr::AO__atomic_xor_fetch:
2956   case AtomicExpr::AO__atomic_nand_fetch:
2957     Val1 = EmitValToTemp(*this, E->getVal1());
2958     break;
2959   }
2960
2961   if (!E->getType()->isVoidType() && !Dest)
2962     Dest = CreateMemTemp(E->getType(), ".atomicdst");
2963
2964   // Use a library call.  See: http://gcc.gnu.org/wiki/Atomic/GCCMM/LIbrary .
2965   if (UseLibcall) {
2966
2967     llvm::SmallVector<QualType, 5> Params;
2968     CallArgList Args;
2969     // Size is always the first parameter
2970     Args.add(RValue::get(llvm::ConstantInt::get(SizeTy, Size)),
2971              getContext().getSizeType());
2972     // Atomic address is always the second parameter
2973     Args.add(RValue::get(EmitCastToVoidPtr(Ptr)),
2974              getContext().VoidPtrTy);
2975
2976     const char* LibCallName;
2977     QualType RetTy = getContext().VoidTy;
2978     switch (E->getOp()) {
2979     // There is only one libcall for compare an exchange, because there is no
2980     // optimisation benefit possible from a libcall version of a weak compare
2981     // and exchange.
2982     // bool __atomic_compare_exchange(size_t size, void *obj, void *expected,
2983     //                                void *desired, int success, int failure)
2984     case AtomicExpr::AO__c11_atomic_compare_exchange_weak:
2985     case AtomicExpr::AO__c11_atomic_compare_exchange_strong:
2986     case AtomicExpr::AO__atomic_compare_exchange:
2987     case AtomicExpr::AO__atomic_compare_exchange_n:
2988       LibCallName = "__atomic_compare_exchange";
2989       RetTy = getContext().BoolTy;
2990       Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
2991                getContext().VoidPtrTy);
2992       Args.add(RValue::get(EmitCastToVoidPtr(Val2)),
2993                getContext().VoidPtrTy);
2994       Args.add(RValue::get(Order),
2995                getContext().IntTy);
2996       Order = OrderFail;
2997       break;
2998     // void __atomic_exchange(size_t size, void *mem, void *val, void *return,
2999     //                        int order)
3000     case AtomicExpr::AO__c11_atomic_exchange:
3001     case AtomicExpr::AO__atomic_exchange_n:
3002     case AtomicExpr::AO__atomic_exchange:
3003       LibCallName = "__atomic_exchange";
3004       Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
3005                getContext().VoidPtrTy);
3006       Args.add(RValue::get(EmitCastToVoidPtr(Dest)),
3007                getContext().VoidPtrTy);
3008       break;
3009     // void __atomic_store(size_t size, void *mem, void *val, int order)
3010     case AtomicExpr::AO__c11_atomic_store:
3011     case AtomicExpr::AO__atomic_store:
3012     case AtomicExpr::AO__atomic_store_n:
3013       LibCallName = "__atomic_store";
3014       Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
3015                getContext().VoidPtrTy);
3016       break;
3017     // void __atomic_load(size_t size, void *mem, void *return, int order)
3018     case AtomicExpr::AO__c11_atomic_load:
3019     case AtomicExpr::AO__atomic_load:
3020     case AtomicExpr::AO__atomic_load_n:
3021       LibCallName = "__atomic_load";
3022       Args.add(RValue::get(EmitCastToVoidPtr(Dest)),
3023                getContext().VoidPtrTy);
3024       break;
3025 #if 0
3026     // These are only defined for 1-16 byte integers.  It is not clear what
3027     // their semantics would be on anything else...
3028     case AtomicExpr::Add:   LibCallName = "__atomic_fetch_add_generic"; break;
3029     case AtomicExpr::Sub:   LibCallName = "__atomic_fetch_sub_generic"; break;
3030     case AtomicExpr::And:   LibCallName = "__atomic_fetch_and_generic"; break;
3031     case AtomicExpr::Or:    LibCallName = "__atomic_fetch_or_generic"; break;
3032     case AtomicExpr::Xor:   LibCallName = "__atomic_fetch_xor_generic"; break;
3033 #endif
3034     default: return EmitUnsupportedRValue(E, "atomic library call");
3035     }
3036     // order is always the last parameter
3037     Args.add(RValue::get(Order),
3038              getContext().IntTy);
3039
3040     const CGFunctionInfo &FuncInfo =
3041         CGM.getTypes().arrangeFunctionCall(RetTy, Args,
3042             FunctionType::ExtInfo(), RequiredArgs::All);
3043     llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FuncInfo);
3044     llvm::Constant *Func = CGM.CreateRuntimeFunction(FTy, LibCallName);
3045     RValue Res = EmitCall(FuncInfo, Func, ReturnValueSlot(), Args);
3046     if (E->isCmpXChg())
3047       return Res;
3048     if (E->getType()->isVoidType())
3049       return RValue::get(0);
3050     return ConvertTempToRValue(*this, E->getType(), Dest);
3051   }
3052
3053   llvm::Type *IPtrTy =
3054       llvm::IntegerType::get(getLLVMContext(), Size * 8)->getPointerTo();
3055   llvm::Value *OrigDest = Dest;
3056   Ptr = Builder.CreateBitCast(Ptr, IPtrTy);
3057   if (Val1) Val1 = Builder.CreateBitCast(Val1, IPtrTy);
3058   if (Val2) Val2 = Builder.CreateBitCast(Val2, IPtrTy);
3059   if (Dest && !E->isCmpXChg()) Dest = Builder.CreateBitCast(Dest, IPtrTy);
3060
3061   if (isa<llvm::ConstantInt>(Order)) {
3062     int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
3063     switch (ord) {
3064     case 0:  // memory_order_relaxed
3065       EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3066                    llvm::Monotonic);
3067       break;
3068     case 1:  // memory_order_consume
3069     case 2:  // memory_order_acquire
3070       EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3071                    llvm::Acquire);
3072       break;
3073     case 3:  // memory_order_release
3074       EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3075                    llvm::Release);
3076       break;
3077     case 4:  // memory_order_acq_rel
3078       EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3079                    llvm::AcquireRelease);
3080       break;
3081     case 5:  // memory_order_seq_cst
3082       EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3083                    llvm::SequentiallyConsistent);
3084       break;
3085     default: // invalid order
3086       // We should not ever get here normally, but it's hard to
3087       // enforce that in general.
3088       break;
3089     }
3090     if (E->getType()->isVoidType())
3091       return RValue::get(0);
3092     return ConvertTempToRValue(*this, E->getType(), OrigDest);
3093   }
3094
3095   // Long case, when Order isn't obviously constant.
3096
3097   bool IsStore = E->getOp() == AtomicExpr::AO__c11_atomic_store ||
3098                  E->getOp() == AtomicExpr::AO__atomic_store ||
3099                  E->getOp() == AtomicExpr::AO__atomic_store_n;
3100   bool IsLoad = E->getOp() == AtomicExpr::AO__c11_atomic_load ||
3101                 E->getOp() == AtomicExpr::AO__atomic_load ||
3102                 E->getOp() == AtomicExpr::AO__atomic_load_n;
3103
3104   // Create all the relevant BB's
3105   llvm::BasicBlock *MonotonicBB = 0, *AcquireBB = 0, *ReleaseBB = 0,
3106                    *AcqRelBB = 0, *SeqCstBB = 0;
3107   MonotonicBB = createBasicBlock("monotonic", CurFn);
3108   if (!IsStore)
3109     AcquireBB = createBasicBlock("acquire", CurFn);
3110   if (!IsLoad)
3111     ReleaseBB = createBasicBlock("release", CurFn);
3112   if (!IsLoad && !IsStore)
3113     AcqRelBB = createBasicBlock("acqrel", CurFn);
3114   SeqCstBB = createBasicBlock("seqcst", CurFn);
3115   llvm::BasicBlock *ContBB = createBasicBlock("atomic.continue", CurFn);
3116
3117   // Create the switch for the split
3118   // MonotonicBB is arbitrarily chosen as the default case; in practice, this
3119   // doesn't matter unless someone is crazy enough to use something that
3120   // doesn't fold to a constant for the ordering.
3121   Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
3122   llvm::SwitchInst *SI = Builder.CreateSwitch(Order, MonotonicBB);
3123
3124   // Emit all the different atomics
3125   Builder.SetInsertPoint(MonotonicBB);
3126   EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3127                llvm::Monotonic);
3128   Builder.CreateBr(ContBB);
3129   if (!IsStore) {
3130     Builder.SetInsertPoint(AcquireBB);
3131     EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3132                  llvm::Acquire);
3133     Builder.CreateBr(ContBB);
3134     SI->addCase(Builder.getInt32(1), AcquireBB);
3135     SI->addCase(Builder.getInt32(2), AcquireBB);
3136   }
3137   if (!IsLoad) {
3138     Builder.SetInsertPoint(ReleaseBB);
3139     EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3140                  llvm::Release);
3141     Builder.CreateBr(ContBB);
3142     SI->addCase(Builder.getInt32(3), ReleaseBB);
3143   }
3144   if (!IsLoad && !IsStore) {
3145     Builder.SetInsertPoint(AcqRelBB);
3146     EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3147                  llvm::AcquireRelease);
3148     Builder.CreateBr(ContBB);
3149     SI->addCase(Builder.getInt32(4), AcqRelBB);
3150   }
3151   Builder.SetInsertPoint(SeqCstBB);
3152   EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
3153                llvm::SequentiallyConsistent);
3154   Builder.CreateBr(ContBB);
3155   SI->addCase(Builder.getInt32(5), SeqCstBB);
3156
3157   // Cleanup and return
3158   Builder.SetInsertPoint(ContBB);
3159   if (E->getType()->isVoidType())
3160     return RValue::get(0);
3161   return ConvertTempToRValue(*this, E->getType(), OrigDest);
3162 }
3163
3164 void CodeGenFunction::SetFPAccuracy(llvm::Value *Val, float Accuracy) {
3165   assert(Val->getType()->isFPOrFPVectorTy());
3166   if (Accuracy == 0.0 || !isa<llvm::Instruction>(Val))
3167     return;
3168
3169   llvm::MDBuilder MDHelper(getLLVMContext());
3170   llvm::MDNode *Node = MDHelper.createFPMath(Accuracy);
3171
3172   cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpmath, Node);
3173 }
3174
3175 namespace {
3176   struct LValueOrRValue {
3177     LValue LV;
3178     RValue RV;
3179   };
3180 }
3181
3182 static LValueOrRValue emitPseudoObjectExpr(CodeGenFunction &CGF,
3183                                            const PseudoObjectExpr *E,
3184                                            bool forLValue,
3185                                            AggValueSlot slot) {
3186   llvm::SmallVector<CodeGenFunction::OpaqueValueMappingData, 4> opaques;
3187
3188   // Find the result expression, if any.
3189   const Expr *resultExpr = E->getResultExpr();
3190   LValueOrRValue result;
3191
3192   for (PseudoObjectExpr::const_semantics_iterator
3193          i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
3194     const Expr *semantic = *i;
3195
3196     // If this semantic expression is an opaque value, bind it
3197     // to the result of its source expression.
3198     if (const OpaqueValueExpr *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
3199
3200       // If this is the result expression, we may need to evaluate
3201       // directly into the slot.
3202       typedef CodeGenFunction::OpaqueValueMappingData OVMA;
3203       OVMA opaqueData;
3204       if (ov == resultExpr && ov->isRValue() && !forLValue &&
3205           CodeGenFunction::hasAggregateLLVMType(ov->getType()) &&
3206           !ov->getType()->isAnyComplexType()) {
3207         CGF.EmitAggExpr(ov->getSourceExpr(), slot);
3208
3209         LValue LV = CGF.MakeAddrLValue(slot.getAddr(), ov->getType());
3210         opaqueData = OVMA::bind(CGF, ov, LV);
3211         result.RV = slot.asRValue();
3212
3213       // Otherwise, emit as normal.
3214       } else {
3215         opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
3216
3217         // If this is the result, also evaluate the result now.
3218         if (ov == resultExpr) {
3219           if (forLValue)
3220             result.LV = CGF.EmitLValue(ov);
3221           else
3222             result.RV = CGF.EmitAnyExpr(ov, slot);
3223         }
3224       }
3225
3226       opaques.push_back(opaqueData);
3227
3228     // Otherwise, if the expression is the result, evaluate it
3229     // and remember the result.
3230     } else if (semantic == resultExpr) {
3231       if (forLValue)
3232         result.LV = CGF.EmitLValue(semantic);
3233       else
3234         result.RV = CGF.EmitAnyExpr(semantic, slot);
3235
3236     // Otherwise, evaluate the expression in an ignored context.
3237     } else {
3238       CGF.EmitIgnoredExpr(semantic);
3239     }
3240   }
3241
3242   // Unbind all the opaques now.
3243   for (unsigned i = 0, e = opaques.size(); i != e; ++i)
3244     opaques[i].unbind(CGF);
3245
3246   return result;
3247 }
3248
3249 RValue CodeGenFunction::EmitPseudoObjectRValue(const PseudoObjectExpr *E,
3250                                                AggValueSlot slot) {
3251   return emitPseudoObjectExpr(*this, E, false, slot).RV;
3252 }
3253
3254 LValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) {
3255   return emitPseudoObjectExpr(*this, E, true, AggValueSlot::ignored()).LV;
3256 }