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