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