• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===--- CGExpr.cpp - Emit LLVM Code from Expressions ---------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 //
10 // This contains code to emit Expr nodes as LLVM code.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #include "CodeGenFunction.h"
15 #include "CGCXXABI.h"
16 #include "CGCall.h"
17 #include "CGDebugInfo.h"
18 #include "CGObjCRuntime.h"
19 #include "CGRecordLayout.h"
20 #include "CodeGenModule.h"
21 #include "TargetInfo.h"
22 #include "clang/AST/ASTContext.h"
23 #include "clang/AST/DeclObjC.h"
24 #include "clang/Frontend/CodeGenOptions.h"
25 #include "llvm/ADT/Hashing.h"
26 #include "llvm/IR/DataLayout.h"
27 #include "llvm/IR/Intrinsics.h"
28 #include "llvm/IR/LLVMContext.h"
29 #include "llvm/IR/MDBuilder.h"
30 #include "llvm/Support/ConvertUTF.h"
31 
32 using namespace clang;
33 using namespace CodeGen;
34 
35 //===--------------------------------------------------------------------===//
36 //                        Miscellaneous Helper Methods
37 //===--------------------------------------------------------------------===//
38 
EmitCastToVoidPtr(llvm::Value * value)39 llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) {
40   unsigned addressSpace =
41     cast<llvm::PointerType>(value->getType())->getAddressSpace();
42 
43   llvm::PointerType *destType = Int8PtrTy;
44   if (addressSpace)
45     destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace);
46 
47   if (value->getType() == destType) return value;
48   return Builder.CreateBitCast(value, destType);
49 }
50 
51 /// CreateTempAlloca - This creates a alloca and inserts it into the entry
52 /// block.
CreateTempAlloca(llvm::Type * Ty,const Twine & Name)53 llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(llvm::Type *Ty,
54                                                     const Twine &Name) {
55   if (!Builder.isNamePreserving())
56     return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt);
57   return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt);
58 }
59 
InitTempAlloca(llvm::AllocaInst * Var,llvm::Value * Init)60 void CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var,
61                                      llvm::Value *Init) {
62   llvm::StoreInst *Store = new llvm::StoreInst(Init, Var);
63   llvm::BasicBlock *Block = AllocaInsertPt->getParent();
64   Block->getInstList().insertAfter(&*AllocaInsertPt, Store);
65 }
66 
CreateIRTemp(QualType Ty,const Twine & Name)67 llvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty,
68                                                 const Twine &Name) {
69   llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name);
70   // FIXME: Should we prefer the preferred type alignment here?
71   CharUnits Align = getContext().getTypeAlignInChars(Ty);
72   Alloc->setAlignment(Align.getQuantity());
73   return Alloc;
74 }
75 
CreateMemTemp(QualType Ty,const Twine & Name)76 llvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty,
77                                                  const Twine &Name) {
78   llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name);
79   // FIXME: Should we prefer the preferred type alignment here?
80   CharUnits Align = getContext().getTypeAlignInChars(Ty);
81   Alloc->setAlignment(Align.getQuantity());
82   return Alloc;
83 }
84 
85 /// EvaluateExprAsBool - Perform the usual unary conversions on the specified
86 /// expression and compare the result against zero, returning an Int1Ty value.
EvaluateExprAsBool(const Expr * E)87 llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) {
88   if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) {
89     llvm::Value *MemPtr = EmitScalarExpr(E);
90     return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT);
91   }
92 
93   QualType BoolTy = getContext().BoolTy;
94   if (!E->getType()->isAnyComplexType())
95     return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy);
96 
97   return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy);
98 }
99 
100 /// EmitIgnoredExpr - Emit code to compute the specified expression,
101 /// ignoring the result.
EmitIgnoredExpr(const Expr * E)102 void CodeGenFunction::EmitIgnoredExpr(const Expr *E) {
103   if (E->isRValue())
104     return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true);
105 
106   // Just emit it as an l-value and drop the result.
107   EmitLValue(E);
108 }
109 
110 /// EmitAnyExpr - Emit code to compute the specified expression which
111 /// can have any type.  The result is returned as an RValue struct.
112 /// If this is an aggregate expression, AggSlot indicates where the
113 /// result should be returned.
EmitAnyExpr(const Expr * E,AggValueSlot aggSlot,bool ignoreResult)114 RValue CodeGenFunction::EmitAnyExpr(const Expr *E,
115                                     AggValueSlot aggSlot,
116                                     bool ignoreResult) {
117   switch (getEvaluationKind(E->getType())) {
118   case TEK_Scalar:
119     return RValue::get(EmitScalarExpr(E, ignoreResult));
120   case TEK_Complex:
121     return RValue::getComplex(EmitComplexExpr(E, ignoreResult, ignoreResult));
122   case TEK_Aggregate:
123     if (!ignoreResult && aggSlot.isIgnored())
124       aggSlot = CreateAggTemp(E->getType(), "agg-temp");
125     EmitAggExpr(E, aggSlot);
126     return aggSlot.asRValue();
127   }
128   llvm_unreachable("bad evaluation kind");
129 }
130 
131 /// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will
132 /// always be accessible even if no aggregate location is provided.
EmitAnyExprToTemp(const Expr * E)133 RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) {
134   AggValueSlot AggSlot = AggValueSlot::ignored();
135 
136   if (hasAggregateEvaluationKind(E->getType()))
137     AggSlot = CreateAggTemp(E->getType(), "agg.tmp");
138   return EmitAnyExpr(E, AggSlot);
139 }
140 
141 /// EmitAnyExprToMem - Evaluate an expression into a given memory
142 /// location.
EmitAnyExprToMem(const Expr * E,llvm::Value * Location,Qualifiers Quals,bool IsInit)143 void CodeGenFunction::EmitAnyExprToMem(const Expr *E,
144                                        llvm::Value *Location,
145                                        Qualifiers Quals,
146                                        bool IsInit) {
147   // FIXME: This function should take an LValue as an argument.
148   switch (getEvaluationKind(E->getType())) {
149   case TEK_Complex:
150     EmitComplexExprIntoLValue(E,
151                          MakeNaturalAlignAddrLValue(Location, E->getType()),
152                               /*isInit*/ false);
153     return;
154 
155   case TEK_Aggregate: {
156     CharUnits Alignment = getContext().getTypeAlignInChars(E->getType());
157     EmitAggExpr(E, AggValueSlot::forAddr(Location, Alignment, Quals,
158                                          AggValueSlot::IsDestructed_t(IsInit),
159                                          AggValueSlot::DoesNotNeedGCBarriers,
160                                          AggValueSlot::IsAliased_t(!IsInit)));
161     return;
162   }
163 
164   case TEK_Scalar: {
165     RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false));
166     LValue LV = MakeAddrLValue(Location, E->getType());
167     EmitStoreThroughLValue(RV, LV);
168     return;
169   }
170   }
171   llvm_unreachable("bad evaluation kind");
172 }
173 
174 static llvm::Value *
CreateReferenceTemporary(CodeGenFunction & CGF,QualType Type,const NamedDecl * InitializedDecl)175 CreateReferenceTemporary(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 
200 static llvm::Value *
EmitExprForReferenceBinding(CodeGenFunction & CGF,const Expr * E,llvm::Value * & ReferenceTemporary,const CXXDestructorDecl * & ReferenceTemporaryDtor,QualType & ObjCARCReferenceLifetimeType,const NamedDecl * InitializedDecl)201 EmitExprForReferenceBinding(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 
394 RValue
EmitReferenceBindingToExpr(const Expr * E,const NamedDecl * InitializedDecl)395 CodeGenFunction::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.
getAccessedFieldNo(unsigned Idx,const llvm::Constant * Elts)483 unsigned 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.
emitHash16Bytes(CGBuilderTy & Builder,llvm::Value * Low,llvm::Value * High)490 static 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 
EmitTypeCheck(TypeCheckKind TCK,SourceLocation Loc,llvm::Value * Address,QualType Ty,CharUnits Alignment)501 void 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.
isFlexibleArrayMemberExpr(const Expr * E)645 static 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.
getArrayIndexingBound(CodeGenFunction & CGF,const Expr * Base,QualType & IndexedType)673 static llvm::Value *getArrayIndexingBound(
674     CodeGenFunction &CGF, const Expr *Base, 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 
EmitBoundsCheck(const Expr * E,const Expr * Base,llvm::Value * Index,QualType IndexType,bool Accessed)698 void 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 
723 CodeGenFunction::ComplexPairTy CodeGenFunction::
EmitComplexPrePostIncDec(const UnaryOperator * E,LValue LV,bool isInc,bool isPre)724 EmitComplexPrePostIncDec(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 
GetUndefRValue(QualType Ty)761 RValue 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 
EmitUnsupportedRValue(const Expr * E,const char * Name)787 RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E,
788                                               const char *Name) {
789   ErrorUnsupported(E, Name);
790   return GetUndefRValue(E->getType());
791 }
792 
EmitUnsupportedLValue(const Expr * E,const char * Name)793 LValue 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 
EmitCheckedLValue(const Expr * E,TypeCheckKind TCK)800 LValue 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 ///
EmitLValue(const Expr * E)827 LValue 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?
isConstantEmittableObjectType(QualType type)934 static 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'.
959 enum ConstantEmissionKind {
960   CEK_None,
961   CEK_AsReferenceOnly,
962   CEK_AsValueOrReference,
963   CEK_AsValueOnly
964 };
checkVarTypeForConstantEmission(QualType type)965 static 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.
982 CodeGenFunction::ConstantEmission
tryEmitAsConstant(DeclRefExpr * refExpr)983 CodeGenFunction::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 
EmitLoadOfScalar(LValue lvalue)1044 llvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue) {
1045   return EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatile(),
1046                           lvalue.getAlignment().getQuantity(),
1047                           lvalue.getType(), lvalue.getTBAAInfo());
1048 }
1049 
hasBooleanRepresentation(QualType Ty)1050 static 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 
getRangeForType(CodeGenFunction & CGF,QualType Ty,llvm::APInt & Min,llvm::APInt & End,bool StrictEnums)1063 static 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 
getRangeForLoadFromType(QualType Ty)1097 llvm::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 
EmitLoadOfScalar(llvm::Value * Addr,bool Volatile,unsigned Alignment,QualType Ty,llvm::MDNode * TBAAInfo)1107 llvm::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 
EmitToMemory(llvm::Value * Value,QualType Ty)1191 llvm::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 
EmitFromMemory(llvm::Value * Value,QualType Ty)1205 llvm::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 
EmitStoreOfScalar(llvm::Value * Value,llvm::Value * Addr,bool Volatile,unsigned Alignment,QualType Ty,llvm::MDNode * TBAAInfo,bool isInit)1216 void 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 
EmitStoreOfScalar(llvm::Value * value,LValue lvalue,bool isInit)1275 void 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.
EmitLoadOfLValue(LValue LV)1285 RValue 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 
EmitLoadOfBitfieldLValue(LValue LV)1322 RValue 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.
EmitLoadOfExtVectorElementLValue(LValue LV)1355 RValue 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'.
EmitStoreThroughLValue(RValue Src,LValue Dst,bool isInit)1390 void 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 
EmitStoreThroughBitfieldLValue(RValue Src,LValue Dst,llvm::Value ** Result)1477 void 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 
EmitStoreThroughExtVectorComponentLValue(RValue Src,LValue Dst)1548 void 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.
setObjCGCLValueClass(const ASTContext & Ctx,const Expr * E,LValue & LV,bool IsMemberAccess=false)1619 static 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 
1716 static llvm::Value *
EmitBitCastOfLValueToProperType(CodeGenFunction & CGF,llvm::Value * V,llvm::Type * IRType,StringRef Name=StringRef ())1717 EmitBitCastOfLValueToProperType(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 
EmitGlobalVarDeclLValue(CodeGenFunction & CGF,const Expr * E,const VarDecl * VD)1724 static 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 
EmitFunctionDeclLValue(CodeGenFunction & CGF,const Expr * E,const FunctionDecl * FD)1744 static 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 
EmitDeclRefLValue(const DeclRefExpr * E)1763 LValue 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     llvm::Value *V = LocalDeclMap.lookup(VD);
1804     if (!V && VD->isStaticLocal())
1805       V = CGM.getStaticLocalDeclAddress(VD);
1806 
1807     // Use special handling for lambdas.
1808     if (!V) {
1809       if (FieldDecl *FD = LambdaCaptureFields.lookup(VD)) {
1810         QualType LambdaTagType = getContext().getTagDeclType(FD->getParent());
1811         LValue LambdaLV = MakeNaturalAlignAddrLValue(CXXABIThisValue,
1812                                                      LambdaTagType);
1813         return EmitLValueForField(LambdaLV, FD);
1814       }
1815 
1816       assert(isa<BlockDecl>(CurCodeDecl) && E->refersToEnclosingLocal());
1817       return MakeAddrLValue(GetAddrOfBlockDecl(VD, isBlockVariable),
1818                             T, Alignment);
1819     }
1820 
1821     assert(V && "DeclRefExpr not entered in LocalDeclMap?");
1822 
1823     if (isBlockVariable)
1824       V = BuildBlockByrefAddress(V, VD);
1825 
1826     LValue LV;
1827     if (VD->getType()->isReferenceType()) {
1828       llvm::LoadInst *LI = Builder.CreateLoad(V);
1829       LI->setAlignment(Alignment.getQuantity());
1830       V = LI;
1831       LV = MakeNaturalAlignAddrLValue(V, T);
1832     } else {
1833       LV = MakeAddrLValue(V, T, Alignment);
1834     }
1835 
1836     bool isLocalStorage = VD->hasLocalStorage();
1837 
1838     bool NonGCable = isLocalStorage &&
1839                      !VD->getType()->isReferenceType() &&
1840                      !isBlockVariable;
1841     if (NonGCable) {
1842       LV.getQuals().removeObjCGCAttr();
1843       LV.setNonGC(true);
1844     }
1845 
1846     bool isImpreciseLifetime =
1847       (isLocalStorage && !VD->hasAttr<ObjCPreciseLifetimeAttr>());
1848     if (isImpreciseLifetime)
1849       LV.setARCPreciseLifetime(ARCImpreciseLifetime);
1850     setObjCGCLValueClass(getContext(), E, LV);
1851     return LV;
1852   }
1853 
1854   if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND))
1855     return EmitFunctionDeclLValue(*this, E, fn);
1856 
1857   llvm_unreachable("Unhandled DeclRefExpr");
1858 }
1859 
EmitUnaryOpLValue(const UnaryOperator * E)1860 LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
1861   // __extension__ doesn't affect lvalue-ness.
1862   if (E->getOpcode() == UO_Extension)
1863     return EmitLValue(E->getSubExpr());
1864 
1865   QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType());
1866   switch (E->getOpcode()) {
1867   default: llvm_unreachable("Unknown unary operator lvalue!");
1868   case UO_Deref: {
1869     QualType T = E->getSubExpr()->getType()->getPointeeType();
1870     assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type");
1871 
1872     LValue LV = MakeNaturalAlignAddrLValue(EmitScalarExpr(E->getSubExpr()), T);
1873     LV.getQuals().setAddressSpace(ExprTy.getAddressSpace());
1874 
1875     // We should not generate __weak write barrier on indirect reference
1876     // of a pointer to object; as in void foo (__weak id *param); *param = 0;
1877     // But, we continue to generate __strong write barrier on indirect write
1878     // into a pointer to object.
1879     if (getLangOpts().ObjC1 &&
1880         getLangOpts().getGC() != LangOptions::NonGC &&
1881         LV.isObjCWeak())
1882       LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
1883     return LV;
1884   }
1885   case UO_Real:
1886   case UO_Imag: {
1887     LValue LV = EmitLValue(E->getSubExpr());
1888     assert(LV.isSimple() && "real/imag on non-ordinary l-value");
1889     llvm::Value *Addr = LV.getAddress();
1890 
1891     // __real is valid on scalars.  This is a faster way of testing that.
1892     // __imag can only produce an rvalue on scalars.
1893     if (E->getOpcode() == UO_Real &&
1894         !cast<llvm::PointerType>(Addr->getType())
1895            ->getElementType()->isStructTy()) {
1896       assert(E->getSubExpr()->getType()->isArithmeticType());
1897       return LV;
1898     }
1899 
1900     assert(E->getSubExpr()->getType()->isAnyComplexType());
1901 
1902     unsigned Idx = E->getOpcode() == UO_Imag;
1903     return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(),
1904                                                   Idx, "idx"),
1905                           ExprTy);
1906   }
1907   case UO_PreInc:
1908   case UO_PreDec: {
1909     LValue LV = EmitLValue(E->getSubExpr());
1910     bool isInc = E->getOpcode() == UO_PreInc;
1911 
1912     if (E->getType()->isAnyComplexType())
1913       EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/);
1914     else
1915       EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/);
1916     return LV;
1917   }
1918   }
1919 }
1920 
EmitStringLiteralLValue(const StringLiteral * E)1921 LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
1922   return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E),
1923                         E->getType());
1924 }
1925 
EmitObjCEncodeExprLValue(const ObjCEncodeExpr * E)1926 LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
1927   return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E),
1928                         E->getType());
1929 }
1930 
1931 static llvm::Constant*
GetAddrOfConstantWideString(StringRef Str,const char * GlobalName,ASTContext & Context,QualType Ty,SourceLocation Loc,CodeGenModule & CGM)1932 GetAddrOfConstantWideString(StringRef Str,
1933                             const char *GlobalName,
1934                             ASTContext &Context,
1935                             QualType Ty, SourceLocation Loc,
1936                             CodeGenModule &CGM) {
1937 
1938   StringLiteral *SL = StringLiteral::Create(Context,
1939                                             Str,
1940                                             StringLiteral::Wide,
1941                                             /*Pascal = */false,
1942                                             Ty, Loc);
1943   llvm::Constant *C = CGM.GetConstantArrayFromStringLiteral(SL);
1944   llvm::GlobalVariable *GV =
1945     new llvm::GlobalVariable(CGM.getModule(), C->getType(),
1946                              !CGM.getLangOpts().WritableStrings,
1947                              llvm::GlobalValue::PrivateLinkage,
1948                              C, GlobalName);
1949   const unsigned WideAlignment =
1950     Context.getTypeAlignInChars(Ty).getQuantity();
1951   GV->setAlignment(WideAlignment);
1952   return GV;
1953 }
1954 
ConvertUTF8ToWideString(unsigned CharByteWidth,StringRef Source,SmallString<32> & Target)1955 static void ConvertUTF8ToWideString(unsigned CharByteWidth, StringRef Source,
1956                                     SmallString<32>& Target) {
1957   Target.resize(CharByteWidth * (Source.size() + 1));
1958   char *ResultPtr = &Target[0];
1959   const UTF8 *ErrorPtr;
1960   bool success = ConvertUTF8toWide(CharByteWidth, Source, ResultPtr, ErrorPtr);
1961   (void)success;
1962   assert(success);
1963   Target.resize(ResultPtr - &Target[0]);
1964 }
1965 
EmitPredefinedLValue(const PredefinedExpr * E)1966 LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
1967   switch (E->getIdentType()) {
1968   default:
1969     return EmitUnsupportedLValue(E, "predefined expression");
1970 
1971   case PredefinedExpr::Func:
1972   case PredefinedExpr::Function:
1973   case PredefinedExpr::LFunction:
1974   case PredefinedExpr::PrettyFunction: {
1975     unsigned IdentType = E->getIdentType();
1976     std::string GlobalVarName;
1977 
1978     switch (IdentType) {
1979     default: llvm_unreachable("Invalid type");
1980     case PredefinedExpr::Func:
1981       GlobalVarName = "__func__.";
1982       break;
1983     case PredefinedExpr::Function:
1984       GlobalVarName = "__FUNCTION__.";
1985       break;
1986     case PredefinedExpr::LFunction:
1987       GlobalVarName = "L__FUNCTION__.";
1988       break;
1989     case PredefinedExpr::PrettyFunction:
1990       GlobalVarName = "__PRETTY_FUNCTION__.";
1991       break;
1992     }
1993 
1994     StringRef FnName = CurFn->getName();
1995     if (FnName.startswith("\01"))
1996       FnName = FnName.substr(1);
1997     GlobalVarName += FnName;
1998 
1999     const Decl *CurDecl = CurCodeDecl;
2000     if (CurDecl == 0)
2001       CurDecl = getContext().getTranslationUnitDecl();
2002 
2003     std::string FunctionName =
2004         (isa<BlockDecl>(CurDecl)
2005          ? FnName.str()
2006          : PredefinedExpr::ComputeName((PredefinedExpr::IdentType)IdentType,
2007                                        CurDecl));
2008 
2009     const Type* ElemType = E->getType()->getArrayElementTypeNoTypeQual();
2010     llvm::Constant *C;
2011     if (ElemType->isWideCharType()) {
2012       SmallString<32> RawChars;
2013       ConvertUTF8ToWideString(
2014           getContext().getTypeSizeInChars(ElemType).getQuantity(),
2015           FunctionName, RawChars);
2016       C = GetAddrOfConstantWideString(RawChars,
2017                                       GlobalVarName.c_str(),
2018                                       getContext(),
2019                                       E->getType(),
2020                                       E->getLocation(),
2021                                       CGM);
2022     } else {
2023       C = CGM.GetAddrOfConstantCString(FunctionName,
2024                                        GlobalVarName.c_str(),
2025                                        1);
2026     }
2027     return MakeAddrLValue(C, E->getType());
2028   }
2029   }
2030 }
2031 
2032 /// Emit a type description suitable for use by a runtime sanitizer library. The
2033 /// format of a type descriptor is
2034 ///
2035 /// \code
2036 ///   { i16 TypeKind, i16 TypeInfo }
2037 /// \endcode
2038 ///
2039 /// followed by an array of i8 containing the type name. TypeKind is 0 for an
2040 /// integer, 1 for a floating point value, and -1 for anything else.
EmitCheckTypeDescriptor(QualType T)2041 llvm::Constant *CodeGenFunction::EmitCheckTypeDescriptor(QualType T) {
2042   // FIXME: Only emit each type's descriptor once.
2043   uint16_t TypeKind = -1;
2044   uint16_t TypeInfo = 0;
2045 
2046   if (T->isIntegerType()) {
2047     TypeKind = 0;
2048     TypeInfo = (llvm::Log2_32(getContext().getTypeSize(T)) << 1) |
2049                (T->isSignedIntegerType() ? 1 : 0);
2050   } else if (T->isFloatingType()) {
2051     TypeKind = 1;
2052     TypeInfo = getContext().getTypeSize(T);
2053   }
2054 
2055   // Format the type name as if for a diagnostic, including quotes and
2056   // optionally an 'aka'.
2057   SmallString<32> Buffer;
2058   CGM.getDiags().ConvertArgToString(DiagnosticsEngine::ak_qualtype,
2059                                     (intptr_t)T.getAsOpaquePtr(),
2060                                     0, 0, 0, 0, 0, 0, Buffer,
2061                                     ArrayRef<intptr_t>());
2062 
2063   llvm::Constant *Components[] = {
2064     Builder.getInt16(TypeKind), Builder.getInt16(TypeInfo),
2065     llvm::ConstantDataArray::getString(getLLVMContext(), Buffer)
2066   };
2067   llvm::Constant *Descriptor = llvm::ConstantStruct::getAnon(Components);
2068 
2069   llvm::GlobalVariable *GV =
2070     new llvm::GlobalVariable(CGM.getModule(), Descriptor->getType(),
2071                              /*isConstant=*/true,
2072                              llvm::GlobalVariable::PrivateLinkage,
2073                              Descriptor);
2074   GV->setUnnamedAddr(true);
2075   return GV;
2076 }
2077 
EmitCheckValue(llvm::Value * V)2078 llvm::Value *CodeGenFunction::EmitCheckValue(llvm::Value *V) {
2079   llvm::Type *TargetTy = IntPtrTy;
2080 
2081   // Integers which fit in intptr_t are zero-extended and passed directly.
2082   if (V->getType()->isIntegerTy() &&
2083       V->getType()->getIntegerBitWidth() <= TargetTy->getIntegerBitWidth())
2084     return Builder.CreateZExt(V, TargetTy);
2085 
2086   // Pointers are passed directly, everything else is passed by address.
2087   if (!V->getType()->isPointerTy()) {
2088     llvm::Value *Ptr = Builder.CreateAlloca(V->getType());
2089     Builder.CreateStore(V, Ptr);
2090     V = Ptr;
2091   }
2092   return Builder.CreatePtrToInt(V, TargetTy);
2093 }
2094 
2095 /// \brief Emit a representation of a SourceLocation for passing to a handler
2096 /// in a sanitizer runtime library. The format for this data is:
2097 /// \code
2098 ///   struct SourceLocation {
2099 ///     const char *Filename;
2100 ///     int32_t Line, Column;
2101 ///   };
2102 /// \endcode
2103 /// For an invalid SourceLocation, the Filename pointer is null.
EmitCheckSourceLocation(SourceLocation Loc)2104 llvm::Constant *CodeGenFunction::EmitCheckSourceLocation(SourceLocation Loc) {
2105   PresumedLoc PLoc = getContext().getSourceManager().getPresumedLoc(Loc);
2106 
2107   llvm::Constant *Data[] = {
2108     // FIXME: Only emit each file name once.
2109     PLoc.isValid() ? cast<llvm::Constant>(
2110                        Builder.CreateGlobalStringPtr(PLoc.getFilename()))
2111                    : llvm::Constant::getNullValue(Int8PtrTy),
2112     Builder.getInt32(PLoc.getLine()),
2113     Builder.getInt32(PLoc.getColumn())
2114   };
2115 
2116   return llvm::ConstantStruct::getAnon(Data);
2117 }
2118 
EmitCheck(llvm::Value * Checked,StringRef CheckName,ArrayRef<llvm::Constant * > StaticArgs,ArrayRef<llvm::Value * > DynamicArgs,CheckRecoverableKind RecoverKind)2119 void CodeGenFunction::EmitCheck(llvm::Value *Checked, StringRef CheckName,
2120                                 ArrayRef<llvm::Constant *> StaticArgs,
2121                                 ArrayRef<llvm::Value *> DynamicArgs,
2122                                 CheckRecoverableKind RecoverKind) {
2123   assert(SanOpts != &SanitizerOptions::Disabled);
2124 
2125   if (CGM.getCodeGenOpts().SanitizeUndefinedTrapOnError) {
2126     assert (RecoverKind != CRK_AlwaysRecoverable &&
2127             "Runtime call required for AlwaysRecoverable kind!");
2128     return EmitTrapCheck(Checked);
2129   }
2130 
2131   llvm::BasicBlock *Cont = createBasicBlock("cont");
2132 
2133   llvm::BasicBlock *Handler = createBasicBlock("handler." + CheckName);
2134 
2135   llvm::Instruction *Branch = Builder.CreateCondBr(Checked, Cont, Handler);
2136 
2137   // Give hint that we very much don't expect to execute the handler
2138   // Value chosen to match UR_NONTAKEN_WEIGHT, see BranchProbabilityInfo.cpp
2139   llvm::MDBuilder MDHelper(getLLVMContext());
2140   llvm::MDNode *Node = MDHelper.createBranchWeights((1U << 20) - 1, 1);
2141   Branch->setMetadata(llvm::LLVMContext::MD_prof, Node);
2142 
2143   EmitBlock(Handler);
2144 
2145   llvm::Constant *Info = llvm::ConstantStruct::getAnon(StaticArgs);
2146   llvm::GlobalValue *InfoPtr =
2147       new llvm::GlobalVariable(CGM.getModule(), Info->getType(), false,
2148                                llvm::GlobalVariable::PrivateLinkage, Info);
2149   InfoPtr->setUnnamedAddr(true);
2150 
2151   SmallVector<llvm::Value *, 4> Args;
2152   SmallVector<llvm::Type *, 4> ArgTypes;
2153   Args.reserve(DynamicArgs.size() + 1);
2154   ArgTypes.reserve(DynamicArgs.size() + 1);
2155 
2156   // Handler functions take an i8* pointing to the (handler-specific) static
2157   // information block, followed by a sequence of intptr_t arguments
2158   // representing operand values.
2159   Args.push_back(Builder.CreateBitCast(InfoPtr, Int8PtrTy));
2160   ArgTypes.push_back(Int8PtrTy);
2161   for (size_t i = 0, n = DynamicArgs.size(); i != n; ++i) {
2162     Args.push_back(EmitCheckValue(DynamicArgs[i]));
2163     ArgTypes.push_back(IntPtrTy);
2164   }
2165 
2166   bool Recover = (RecoverKind == CRK_AlwaysRecoverable) ||
2167                  ((RecoverKind == CRK_Recoverable) &&
2168                    CGM.getCodeGenOpts().SanitizeRecover);
2169 
2170   llvm::FunctionType *FnType =
2171     llvm::FunctionType::get(CGM.VoidTy, ArgTypes, false);
2172   llvm::AttrBuilder B;
2173   if (!Recover) {
2174     B.addAttribute(llvm::Attribute::NoReturn)
2175      .addAttribute(llvm::Attribute::NoUnwind);
2176   }
2177   B.addAttribute(llvm::Attribute::UWTable);
2178 
2179   // Checks that have two variants use a suffix to differentiate them
2180   bool NeedsAbortSuffix = (RecoverKind != CRK_Unrecoverable) &&
2181                            !CGM.getCodeGenOpts().SanitizeRecover;
2182   std::string FunctionName = ("__ubsan_handle_" + CheckName +
2183                               (NeedsAbortSuffix? "_abort" : "")).str();
2184   llvm::Value *Fn =
2185     CGM.CreateRuntimeFunction(FnType, FunctionName,
2186                               llvm::AttributeSet::get(getLLVMContext(),
2187                                               llvm::AttributeSet::FunctionIndex,
2188                                                       B));
2189   llvm::CallInst *HandlerCall = EmitNounwindRuntimeCall(Fn, Args);
2190   if (Recover) {
2191     Builder.CreateBr(Cont);
2192   } else {
2193     HandlerCall->setDoesNotReturn();
2194     Builder.CreateUnreachable();
2195   }
2196 
2197   EmitBlock(Cont);
2198 }
2199 
EmitTrapCheck(llvm::Value * Checked)2200 void CodeGenFunction::EmitTrapCheck(llvm::Value *Checked) {
2201   llvm::BasicBlock *Cont = createBasicBlock("cont");
2202 
2203   // If we're optimizing, collapse all calls to trap down to just one per
2204   // function to save on code size.
2205   if (!CGM.getCodeGenOpts().OptimizationLevel || !TrapBB) {
2206     TrapBB = createBasicBlock("trap");
2207     Builder.CreateCondBr(Checked, Cont, TrapBB);
2208     EmitBlock(TrapBB);
2209     llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap);
2210     llvm::CallInst *TrapCall = Builder.CreateCall(F);
2211     TrapCall->setDoesNotReturn();
2212     TrapCall->setDoesNotThrow();
2213     Builder.CreateUnreachable();
2214   } else {
2215     Builder.CreateCondBr(Checked, Cont, TrapBB);
2216   }
2217 
2218   EmitBlock(Cont);
2219 }
2220 
2221 /// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an
2222 /// array to pointer, return the array subexpression.
isSimpleArrayDecayOperand(const Expr * E)2223 static const Expr *isSimpleArrayDecayOperand(const Expr *E) {
2224   // If this isn't just an array->pointer decay, bail out.
2225   const CastExpr *CE = dyn_cast<CastExpr>(E);
2226   if (CE == 0 || CE->getCastKind() != CK_ArrayToPointerDecay)
2227     return 0;
2228 
2229   // If this is a decay from variable width array, bail out.
2230   const Expr *SubExpr = CE->getSubExpr();
2231   if (SubExpr->getType()->isVariableArrayType())
2232     return 0;
2233 
2234   return SubExpr;
2235 }
2236 
EmitArraySubscriptExpr(const ArraySubscriptExpr * E,bool Accessed)2237 LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E,
2238                                                bool Accessed) {
2239   // The index must always be an integer, which is not an aggregate.  Emit it.
2240   llvm::Value *Idx = EmitScalarExpr(E->getIdx());
2241   QualType IdxTy  = E->getIdx()->getType();
2242   bool IdxSigned = IdxTy->isSignedIntegerOrEnumerationType();
2243 
2244   if (SanOpts->Bounds)
2245     EmitBoundsCheck(E, E->getBase(), Idx, IdxTy, Accessed);
2246 
2247   // If the base is a vector type, then we are forming a vector element lvalue
2248   // with this subscript.
2249   if (E->getBase()->getType()->isVectorType()) {
2250     // Emit the vector as an lvalue to get its address.
2251     LValue LHS = EmitLValue(E->getBase());
2252     assert(LHS.isSimple() && "Can only subscript lvalue vectors here!");
2253     Idx = Builder.CreateIntCast(Idx, Int32Ty, IdxSigned, "vidx");
2254     return LValue::MakeVectorElt(LHS.getAddress(), Idx,
2255                                  E->getBase()->getType(), LHS.getAlignment());
2256   }
2257 
2258   // Extend or truncate the index type to 32 or 64-bits.
2259   if (Idx->getType() != IntPtrTy)
2260     Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom");
2261 
2262   // We know that the pointer points to a type of the correct size, unless the
2263   // size is a VLA or Objective-C interface.
2264   llvm::Value *Address = 0;
2265   CharUnits ArrayAlignment;
2266   if (const VariableArrayType *vla =
2267         getContext().getAsVariableArrayType(E->getType())) {
2268     // The base must be a pointer, which is not an aggregate.  Emit
2269     // it.  It needs to be emitted first in case it's what captures
2270     // the VLA bounds.
2271     Address = EmitScalarExpr(E->getBase());
2272 
2273     // The element count here is the total number of non-VLA elements.
2274     llvm::Value *numElements = getVLASize(vla).first;
2275 
2276     // Effectively, the multiply by the VLA size is part of the GEP.
2277     // GEP indexes are signed, and scaling an index isn't permitted to
2278     // signed-overflow, so we use the same semantics for our explicit
2279     // multiply.  We suppress this if overflow is not undefined behavior.
2280     if (getLangOpts().isSignedOverflowDefined()) {
2281       Idx = Builder.CreateMul(Idx, numElements);
2282       Address = Builder.CreateGEP(Address, Idx, "arrayidx");
2283     } else {
2284       Idx = Builder.CreateNSWMul(Idx, numElements);
2285       Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx");
2286     }
2287   } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){
2288     // Indexing over an interface, as in "NSString *P; P[4];"
2289     llvm::Value *InterfaceSize =
2290       llvm::ConstantInt::get(Idx->getType(),
2291           getContext().getTypeSizeInChars(OIT).getQuantity());
2292 
2293     Idx = Builder.CreateMul(Idx, InterfaceSize);
2294 
2295     // The base must be a pointer, which is not an aggregate.  Emit it.
2296     llvm::Value *Base = EmitScalarExpr(E->getBase());
2297     Address = EmitCastToVoidPtr(Base);
2298     Address = Builder.CreateGEP(Address, Idx, "arrayidx");
2299     Address = Builder.CreateBitCast(Address, Base->getType());
2300   } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
2301     // If this is A[i] where A is an array, the frontend will have decayed the
2302     // base to be a ArrayToPointerDecay implicit cast.  While correct, it is
2303     // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a
2304     // "gep x, i" here.  Emit one "gep A, 0, i".
2305     assert(Array->getType()->isArrayType() &&
2306            "Array to pointer decay must have array source type!");
2307     LValue ArrayLV;
2308     // For simple multidimensional array indexing, set the 'accessed' flag for
2309     // better bounds-checking of the base expression.
2310     if (const ArraySubscriptExpr *ASE = dyn_cast<ArraySubscriptExpr>(Array))
2311       ArrayLV = EmitArraySubscriptExpr(ASE, /*Accessed*/ true);
2312     else
2313       ArrayLV = EmitLValue(Array);
2314     llvm::Value *ArrayPtr = ArrayLV.getAddress();
2315     llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0);
2316     llvm::Value *Args[] = { Zero, Idx };
2317 
2318     // Propagate the alignment from the array itself to the result.
2319     ArrayAlignment = ArrayLV.getAlignment();
2320 
2321     if (getLangOpts().isSignedOverflowDefined())
2322       Address = Builder.CreateGEP(ArrayPtr, Args, "arrayidx");
2323     else
2324       Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, "arrayidx");
2325   } else {
2326     // The base must be a pointer, which is not an aggregate.  Emit it.
2327     llvm::Value *Base = EmitScalarExpr(E->getBase());
2328     if (getLangOpts().isSignedOverflowDefined())
2329       Address = Builder.CreateGEP(Base, Idx, "arrayidx");
2330     else
2331       Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
2332   }
2333 
2334   QualType T = E->getBase()->getType()->getPointeeType();
2335   assert(!T.isNull() &&
2336          "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type");
2337 
2338 
2339   // Limit the alignment to that of the result type.
2340   LValue LV;
2341   if (!ArrayAlignment.isZero()) {
2342     CharUnits Align = getContext().getTypeAlignInChars(T);
2343     ArrayAlignment = std::min(Align, ArrayAlignment);
2344     LV = MakeAddrLValue(Address, T, ArrayAlignment);
2345   } else {
2346     LV = MakeNaturalAlignAddrLValue(Address, T);
2347   }
2348 
2349   LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace());
2350 
2351   if (getLangOpts().ObjC1 &&
2352       getLangOpts().getGC() != LangOptions::NonGC) {
2353     LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
2354     setObjCGCLValueClass(getContext(), E, LV);
2355   }
2356   return LV;
2357 }
2358 
2359 static
GenerateConstantVector(CGBuilderTy & Builder,SmallVector<unsigned,4> & Elts)2360 llvm::Constant *GenerateConstantVector(CGBuilderTy &Builder,
2361                                        SmallVector<unsigned, 4> &Elts) {
2362   SmallVector<llvm::Constant*, 4> CElts;
2363   for (unsigned i = 0, e = Elts.size(); i != e; ++i)
2364     CElts.push_back(Builder.getInt32(Elts[i]));
2365 
2366   return llvm::ConstantVector::get(CElts);
2367 }
2368 
2369 LValue CodeGenFunction::
EmitExtVectorElementExpr(const ExtVectorElementExpr * E)2370 EmitExtVectorElementExpr(const ExtVectorElementExpr *E) {
2371   // Emit the base vector as an l-value.
2372   LValue Base;
2373 
2374   // ExtVectorElementExpr's base can either be a vector or pointer to vector.
2375   if (E->isArrow()) {
2376     // If it is a pointer to a vector, emit the address and form an lvalue with
2377     // it.
2378     llvm::Value *Ptr = EmitScalarExpr(E->getBase());
2379     const PointerType *PT = E->getBase()->getType()->getAs<PointerType>();
2380     Base = MakeAddrLValue(Ptr, PT->getPointeeType());
2381     Base.getQuals().removeObjCGCAttr();
2382   } else if (E->getBase()->isGLValue()) {
2383     // Otherwise, if the base is an lvalue ( as in the case of foo.x.x),
2384     // emit the base as an lvalue.
2385     assert(E->getBase()->getType()->isVectorType());
2386     Base = EmitLValue(E->getBase());
2387   } else {
2388     // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such.
2389     assert(E->getBase()->getType()->isVectorType() &&
2390            "Result must be a vector");
2391     llvm::Value *Vec = EmitScalarExpr(E->getBase());
2392 
2393     // Store the vector to memory (because LValue wants an address).
2394     llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType());
2395     Builder.CreateStore(Vec, VecMem);
2396     Base = MakeAddrLValue(VecMem, E->getBase()->getType());
2397   }
2398 
2399   QualType type =
2400     E->getType().withCVRQualifiers(Base.getQuals().getCVRQualifiers());
2401 
2402   // Encode the element access list into a vector of unsigned indices.
2403   SmallVector<unsigned, 4> Indices;
2404   E->getEncodedElementAccess(Indices);
2405 
2406   if (Base.isSimple()) {
2407     llvm::Constant *CV = GenerateConstantVector(Builder, Indices);
2408     return LValue::MakeExtVectorElt(Base.getAddress(), CV, type,
2409                                     Base.getAlignment());
2410   }
2411   assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!");
2412 
2413   llvm::Constant *BaseElts = Base.getExtVectorElts();
2414   SmallVector<llvm::Constant *, 4> CElts;
2415 
2416   for (unsigned i = 0, e = Indices.size(); i != e; ++i)
2417     CElts.push_back(BaseElts->getAggregateElement(Indices[i]));
2418   llvm::Constant *CV = llvm::ConstantVector::get(CElts);
2419   return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, type,
2420                                   Base.getAlignment());
2421 }
2422 
EmitMemberExpr(const MemberExpr * E)2423 LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
2424   Expr *BaseExpr = E->getBase();
2425 
2426   // If this is s.x, emit s as an lvalue.  If it is s->x, emit s as a scalar.
2427   LValue BaseLV;
2428   if (E->isArrow()) {
2429     llvm::Value *Ptr = EmitScalarExpr(BaseExpr);
2430     QualType PtrTy = BaseExpr->getType()->getPointeeType();
2431     EmitTypeCheck(TCK_MemberAccess, E->getExprLoc(), Ptr, PtrTy);
2432     BaseLV = MakeNaturalAlignAddrLValue(Ptr, PtrTy);
2433   } else
2434     BaseLV = EmitCheckedLValue(BaseExpr, TCK_MemberAccess);
2435 
2436   NamedDecl *ND = E->getMemberDecl();
2437   if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) {
2438     LValue LV = EmitLValueForField(BaseLV, Field);
2439     setObjCGCLValueClass(getContext(), E, LV);
2440     return LV;
2441   }
2442 
2443   if (VarDecl *VD = dyn_cast<VarDecl>(ND))
2444     return EmitGlobalVarDeclLValue(*this, E, VD);
2445 
2446   if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
2447     return EmitFunctionDeclLValue(*this, E, FD);
2448 
2449   llvm_unreachable("Unhandled member declaration!");
2450 }
2451 
EmitLValueForField(LValue base,const FieldDecl * field)2452 LValue CodeGenFunction::EmitLValueForField(LValue base,
2453                                            const FieldDecl *field) {
2454   if (field->isBitField()) {
2455     const CGRecordLayout &RL =
2456       CGM.getTypes().getCGRecordLayout(field->getParent());
2457     const CGBitFieldInfo &Info = RL.getBitFieldInfo(field);
2458     llvm::Value *Addr = base.getAddress();
2459     unsigned Idx = RL.getLLVMFieldNo(field);
2460     if (Idx != 0)
2461       // For structs, we GEP to the field that the record layout suggests.
2462       Addr = Builder.CreateStructGEP(Addr, Idx, field->getName());
2463     // Get the access type.
2464     llvm::Type *PtrTy = llvm::Type::getIntNPtrTy(
2465       getLLVMContext(), Info.StorageSize,
2466       CGM.getContext().getTargetAddressSpace(base.getType()));
2467     if (Addr->getType() != PtrTy)
2468       Addr = Builder.CreateBitCast(Addr, PtrTy);
2469 
2470     QualType fieldType =
2471       field->getType().withCVRQualifiers(base.getVRQualifiers());
2472     return LValue::MakeBitfield(Addr, Info, fieldType, base.getAlignment());
2473   }
2474 
2475   const RecordDecl *rec = field->getParent();
2476   QualType type = field->getType();
2477   CharUnits alignment = getContext().getDeclAlign(field);
2478 
2479   // FIXME: It should be impossible to have an LValue without alignment for a
2480   // complete type.
2481   if (!base.getAlignment().isZero())
2482     alignment = std::min(alignment, base.getAlignment());
2483 
2484   bool mayAlias = rec->hasAttr<MayAliasAttr>();
2485 
2486   llvm::Value *addr = base.getAddress();
2487   unsigned cvr = base.getVRQualifiers();
2488   if (rec->isUnion()) {
2489     // For unions, there is no pointer adjustment.
2490     assert(!type->isReferenceType() && "union has reference member");
2491   } else {
2492     // For structs, we GEP to the field that the record layout suggests.
2493     unsigned idx = CGM.getTypes().getCGRecordLayout(rec).getLLVMFieldNo(field);
2494     addr = Builder.CreateStructGEP(addr, idx, field->getName());
2495 
2496     // If this is a reference field, load the reference right now.
2497     if (const ReferenceType *refType = type->getAs<ReferenceType>()) {
2498       llvm::LoadInst *load = Builder.CreateLoad(addr, "ref");
2499       if (cvr & Qualifiers::Volatile) load->setVolatile(true);
2500       load->setAlignment(alignment.getQuantity());
2501 
2502       if (CGM.shouldUseTBAA()) {
2503         llvm::MDNode *tbaa;
2504         if (mayAlias)
2505           tbaa = CGM.getTBAAInfo(getContext().CharTy);
2506         else
2507           tbaa = CGM.getTBAAInfo(type);
2508         CGM.DecorateInstruction(load, tbaa);
2509       }
2510 
2511       addr = load;
2512       mayAlias = false;
2513       type = refType->getPointeeType();
2514       if (type->isIncompleteType())
2515         alignment = CharUnits();
2516       else
2517         alignment = getContext().getTypeAlignInChars(type);
2518       cvr = 0; // qualifiers don't recursively apply to referencee
2519     }
2520   }
2521 
2522   // Make sure that the address is pointing to the right type.  This is critical
2523   // for both unions and structs.  A union needs a bitcast, a struct element
2524   // will need a bitcast if the LLVM type laid out doesn't match the desired
2525   // type.
2526   addr = EmitBitCastOfLValueToProperType(*this, addr,
2527                                          CGM.getTypes().ConvertTypeForMem(type),
2528                                          field->getName());
2529 
2530   if (field->hasAttr<AnnotateAttr>())
2531     addr = EmitFieldAnnotations(field, addr);
2532 
2533   LValue LV = MakeAddrLValue(addr, type, alignment);
2534   LV.getQuals().addCVRQualifiers(cvr);
2535 
2536   // __weak attribute on a field is ignored.
2537   if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak)
2538     LV.getQuals().removeObjCGCAttr();
2539 
2540   // Fields of may_alias structs act like 'char' for TBAA purposes.
2541   // FIXME: this should get propagated down through anonymous structs
2542   // and unions.
2543   if (mayAlias && LV.getTBAAInfo())
2544     LV.setTBAAInfo(CGM.getTBAAInfo(getContext().CharTy));
2545 
2546   return LV;
2547 }
2548 
2549 LValue
EmitLValueForFieldInitialization(LValue Base,const FieldDecl * Field)2550 CodeGenFunction::EmitLValueForFieldInitialization(LValue Base,
2551                                                   const FieldDecl *Field) {
2552   QualType FieldType = Field->getType();
2553 
2554   if (!FieldType->isReferenceType())
2555     return EmitLValueForField(Base, Field);
2556 
2557   const CGRecordLayout &RL =
2558     CGM.getTypes().getCGRecordLayout(Field->getParent());
2559   unsigned idx = RL.getLLVMFieldNo(Field);
2560   llvm::Value *V = Builder.CreateStructGEP(Base.getAddress(), idx);
2561   assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
2562 
2563   // Make sure that the address is pointing to the right type.  This is critical
2564   // for both unions and structs.  A union needs a bitcast, a struct element
2565   // will need a bitcast if the LLVM type laid out doesn't match the desired
2566   // type.
2567   llvm::Type *llvmType = ConvertTypeForMem(FieldType);
2568   V = EmitBitCastOfLValueToProperType(*this, V, llvmType, Field->getName());
2569 
2570   CharUnits Alignment = getContext().getDeclAlign(Field);
2571 
2572   // FIXME: It should be impossible to have an LValue without alignment for a
2573   // complete type.
2574   if (!Base.getAlignment().isZero())
2575     Alignment = std::min(Alignment, Base.getAlignment());
2576 
2577   return MakeAddrLValue(V, FieldType, Alignment);
2578 }
2579 
EmitCompoundLiteralLValue(const CompoundLiteralExpr * E)2580 LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){
2581   if (E->isFileScope()) {
2582     llvm::Value *GlobalPtr = CGM.GetAddrOfConstantCompoundLiteral(E);
2583     return MakeAddrLValue(GlobalPtr, E->getType());
2584   }
2585   if (E->getType()->isVariablyModifiedType())
2586     // make sure to emit the VLA size.
2587     EmitVariablyModifiedType(E->getType());
2588 
2589   llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral");
2590   const Expr *InitExpr = E->getInitializer();
2591   LValue Result = MakeAddrLValue(DeclPtr, E->getType());
2592 
2593   EmitAnyExprToMem(InitExpr, DeclPtr, E->getType().getQualifiers(),
2594                    /*Init*/ true);
2595 
2596   return Result;
2597 }
2598 
EmitInitListLValue(const InitListExpr * E)2599 LValue CodeGenFunction::EmitInitListLValue(const InitListExpr *E) {
2600   if (!E->isGLValue())
2601     // Initializing an aggregate temporary in C++11: T{...}.
2602     return EmitAggExprToLValue(E);
2603 
2604   // An lvalue initializer list must be initializing a reference.
2605   assert(E->getNumInits() == 1 && "reference init with multiple values");
2606   return EmitLValue(E->getInit(0));
2607 }
2608 
2609 LValue CodeGenFunction::
EmitConditionalOperatorLValue(const AbstractConditionalOperator * expr)2610 EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) {
2611   if (!expr->isGLValue()) {
2612     // ?: here should be an aggregate.
2613     assert(hasAggregateEvaluationKind(expr->getType()) &&
2614            "Unexpected conditional operator!");
2615     return EmitAggExprToLValue(expr);
2616   }
2617 
2618   OpaqueValueMapping binding(*this, expr);
2619 
2620   const Expr *condExpr = expr->getCond();
2621   bool CondExprBool;
2622   if (ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
2623     const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr();
2624     if (!CondExprBool) std::swap(live, dead);
2625 
2626     if (!ContainsLabel(dead))
2627       return EmitLValue(live);
2628   }
2629 
2630   llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true");
2631   llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false");
2632   llvm::BasicBlock *contBlock = createBasicBlock("cond.end");
2633 
2634   ConditionalEvaluation eval(*this);
2635   EmitBranchOnBoolExpr(condExpr, lhsBlock, rhsBlock);
2636 
2637   // Any temporaries created here are conditional.
2638   EmitBlock(lhsBlock);
2639   eval.begin(*this);
2640   LValue lhs = EmitLValue(expr->getTrueExpr());
2641   eval.end(*this);
2642 
2643   if (!lhs.isSimple())
2644     return EmitUnsupportedLValue(expr, "conditional operator");
2645 
2646   lhsBlock = Builder.GetInsertBlock();
2647   Builder.CreateBr(contBlock);
2648 
2649   // Any temporaries created here are conditional.
2650   EmitBlock(rhsBlock);
2651   eval.begin(*this);
2652   LValue rhs = EmitLValue(expr->getFalseExpr());
2653   eval.end(*this);
2654   if (!rhs.isSimple())
2655     return EmitUnsupportedLValue(expr, "conditional operator");
2656   rhsBlock = Builder.GetInsertBlock();
2657 
2658   EmitBlock(contBlock);
2659 
2660   llvm::PHINode *phi = Builder.CreatePHI(lhs.getAddress()->getType(), 2,
2661                                          "cond-lvalue");
2662   phi->addIncoming(lhs.getAddress(), lhsBlock);
2663   phi->addIncoming(rhs.getAddress(), rhsBlock);
2664   return MakeAddrLValue(phi, expr->getType());
2665 }
2666 
2667 /// EmitCastLValue - Casts are never lvalues unless that cast is to a reference
2668 /// type. If the cast is to a reference, we can have the usual lvalue result,
2669 /// otherwise if a cast is needed by the code generator in an lvalue context,
2670 /// then it must mean that we need the address of an aggregate in order to
2671 /// access one of its members.  This can happen for all the reasons that casts
2672 /// are permitted with aggregate result, including noop aggregate casts, and
2673 /// cast from scalar to union.
EmitCastLValue(const CastExpr * E)2674 LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
2675   switch (E->getCastKind()) {
2676   case CK_ToVoid:
2677     return EmitUnsupportedLValue(E, "unexpected cast lvalue");
2678 
2679   case CK_Dependent:
2680     llvm_unreachable("dependent cast kind in IR gen!");
2681 
2682   case CK_BuiltinFnToFnPtr:
2683     llvm_unreachable("builtin functions are handled elsewhere");
2684 
2685   // These two casts are currently treated as no-ops, although they could
2686   // potentially be real operations depending on the target's ABI.
2687   case CK_NonAtomicToAtomic:
2688   case CK_AtomicToNonAtomic:
2689 
2690   case CK_NoOp:
2691   case CK_LValueToRValue:
2692     if (!E->getSubExpr()->Classify(getContext()).isPRValue()
2693         || E->getType()->isRecordType())
2694       return EmitLValue(E->getSubExpr());
2695     // Fall through to synthesize a temporary.
2696 
2697   case CK_BitCast:
2698   case CK_ArrayToPointerDecay:
2699   case CK_FunctionToPointerDecay:
2700   case CK_NullToMemberPointer:
2701   case CK_NullToPointer:
2702   case CK_IntegralToPointer:
2703   case CK_PointerToIntegral:
2704   case CK_PointerToBoolean:
2705   case CK_VectorSplat:
2706   case CK_IntegralCast:
2707   case CK_IntegralToBoolean:
2708   case CK_IntegralToFloating:
2709   case CK_FloatingToIntegral:
2710   case CK_FloatingToBoolean:
2711   case CK_FloatingCast:
2712   case CK_FloatingRealToComplex:
2713   case CK_FloatingComplexToReal:
2714   case CK_FloatingComplexToBoolean:
2715   case CK_FloatingComplexCast:
2716   case CK_FloatingComplexToIntegralComplex:
2717   case CK_IntegralRealToComplex:
2718   case CK_IntegralComplexToReal:
2719   case CK_IntegralComplexToBoolean:
2720   case CK_IntegralComplexCast:
2721   case CK_IntegralComplexToFloatingComplex:
2722   case CK_DerivedToBaseMemberPointer:
2723   case CK_BaseToDerivedMemberPointer:
2724   case CK_MemberPointerToBoolean:
2725   case CK_ReinterpretMemberPointer:
2726   case CK_AnyPointerToBlockPointerCast:
2727   case CK_ARCProduceObject:
2728   case CK_ARCConsumeObject:
2729   case CK_ARCReclaimReturnedObject:
2730   case CK_ARCExtendBlockObject:
2731   case CK_CopyAndAutoreleaseBlockObject: {
2732     // These casts only produce lvalues when we're binding a reference to a
2733     // temporary realized from a (converted) pure rvalue. Emit the expression
2734     // as a value, copy it into a temporary, and return an lvalue referring to
2735     // that temporary.
2736     llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp");
2737     EmitAnyExprToMem(E, V, E->getType().getQualifiers(), false);
2738     return MakeAddrLValue(V, E->getType());
2739   }
2740 
2741   case CK_Dynamic: {
2742     LValue LV = EmitLValue(E->getSubExpr());
2743     llvm::Value *V = LV.getAddress();
2744     const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E);
2745     return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType());
2746   }
2747 
2748   case CK_ConstructorConversion:
2749   case CK_UserDefinedConversion:
2750   case CK_CPointerToObjCPointerCast:
2751   case CK_BlockPointerToObjCPointerCast:
2752     return EmitLValue(E->getSubExpr());
2753 
2754   case CK_UncheckedDerivedToBase:
2755   case CK_DerivedToBase: {
2756     const RecordType *DerivedClassTy =
2757       E->getSubExpr()->getType()->getAs<RecordType>();
2758     CXXRecordDecl *DerivedClassDecl =
2759       cast<CXXRecordDecl>(DerivedClassTy->getDecl());
2760 
2761     LValue LV = EmitLValue(E->getSubExpr());
2762     llvm::Value *This = LV.getAddress();
2763 
2764     // Perform the derived-to-base conversion
2765     llvm::Value *Base =
2766       GetAddressOfBaseClass(This, DerivedClassDecl,
2767                             E->path_begin(), E->path_end(),
2768                             /*NullCheckValue=*/false);
2769 
2770     return MakeAddrLValue(Base, E->getType());
2771   }
2772   case CK_ToUnion:
2773     return EmitAggExprToLValue(E);
2774   case CK_BaseToDerived: {
2775     const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>();
2776     CXXRecordDecl *DerivedClassDecl =
2777       cast<CXXRecordDecl>(DerivedClassTy->getDecl());
2778 
2779     LValue LV = EmitLValue(E->getSubExpr());
2780 
2781     // C++11 [expr.static.cast]p2: Behavior is undefined if a downcast is
2782     // performed and the object is not of the derived type.
2783     if (SanitizePerformTypeCheck)
2784       EmitTypeCheck(TCK_DowncastReference, E->getExprLoc(),
2785                     LV.getAddress(), E->getType());
2786 
2787     // Perform the base-to-derived conversion
2788     llvm::Value *Derived =
2789       GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl,
2790                                E->path_begin(), E->path_end(),
2791                                /*NullCheckValue=*/false);
2792 
2793     return MakeAddrLValue(Derived, E->getType());
2794   }
2795   case CK_LValueBitCast: {
2796     // This must be a reinterpret_cast (or c-style equivalent).
2797     const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E);
2798 
2799     LValue LV = EmitLValue(E->getSubExpr());
2800     llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2801                                            ConvertType(CE->getTypeAsWritten()));
2802     return MakeAddrLValue(V, E->getType());
2803   }
2804   case CK_ObjCObjectLValueCast: {
2805     LValue LV = EmitLValue(E->getSubExpr());
2806     QualType ToType = getContext().getLValueReferenceType(E->getType());
2807     llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2808                                            ConvertType(ToType));
2809     return MakeAddrLValue(V, E->getType());
2810   }
2811   case CK_ZeroToOCLEvent:
2812     llvm_unreachable("NULL to OpenCL event lvalue cast is not valid");
2813   }
2814 
2815   llvm_unreachable("Unhandled lvalue cast kind?");
2816 }
2817 
EmitNullInitializationLValue(const CXXScalarValueInitExpr * E)2818 LValue CodeGenFunction::EmitNullInitializationLValue(
2819                                               const CXXScalarValueInitExpr *E) {
2820   QualType Ty = E->getType();
2821   LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty);
2822   EmitNullInitialization(LV.getAddress(), Ty);
2823   return LV;
2824 }
2825 
EmitOpaqueValueLValue(const OpaqueValueExpr * e)2826 LValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) {
2827   assert(OpaqueValueMappingData::shouldBindAsLValue(e));
2828   return getOpaqueLValueMapping(e);
2829 }
2830 
EmitMaterializeTemporaryExpr(const MaterializeTemporaryExpr * E)2831 LValue CodeGenFunction::EmitMaterializeTemporaryExpr(
2832                                            const MaterializeTemporaryExpr *E) {
2833   RValue RV = EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
2834   return MakeAddrLValue(RV.getScalarVal(), E->getType());
2835 }
2836 
EmitRValueForField(LValue LV,const FieldDecl * FD)2837 RValue CodeGenFunction::EmitRValueForField(LValue LV,
2838                                            const FieldDecl *FD) {
2839   QualType FT = FD->getType();
2840   LValue FieldLV = EmitLValueForField(LV, FD);
2841   switch (getEvaluationKind(FT)) {
2842   case TEK_Complex:
2843     return RValue::getComplex(EmitLoadOfComplex(FieldLV));
2844   case TEK_Aggregate:
2845     return FieldLV.asAggregateRValue();
2846   case TEK_Scalar:
2847     return EmitLoadOfLValue(FieldLV);
2848   }
2849   llvm_unreachable("bad evaluation kind");
2850 }
2851 
2852 //===--------------------------------------------------------------------===//
2853 //                             Expression Emission
2854 //===--------------------------------------------------------------------===//
2855 
EmitCallExpr(const CallExpr * E,ReturnValueSlot ReturnValue)2856 RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
2857                                      ReturnValueSlot ReturnValue) {
2858   if (CGDebugInfo *DI = getDebugInfo()) {
2859     SourceLocation Loc = E->getLocStart();
2860     // Force column info to be generated so we can differentiate
2861     // multiple call sites on the same line in the debug info.
2862     const FunctionDecl* Callee = E->getDirectCallee();
2863     bool ForceColumnInfo = Callee && Callee->isInlineSpecified();
2864     DI->EmitLocation(Builder, Loc, ForceColumnInfo);
2865   }
2866 
2867   // Builtins never have block type.
2868   if (E->getCallee()->getType()->isBlockPointerType())
2869     return EmitBlockCallExpr(E, ReturnValue);
2870 
2871   if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E))
2872     return EmitCXXMemberCallExpr(CE, ReturnValue);
2873 
2874   if (const CUDAKernelCallExpr *CE = dyn_cast<CUDAKernelCallExpr>(E))
2875     return EmitCUDAKernelCallExpr(CE, ReturnValue);
2876 
2877   const Decl *TargetDecl = E->getCalleeDecl();
2878   if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
2879     if (unsigned builtinID = FD->getBuiltinID())
2880       return EmitBuiltinExpr(FD, builtinID, E);
2881   }
2882 
2883   if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E))
2884     if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl))
2885       return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue);
2886 
2887   if (const CXXPseudoDestructorExpr *PseudoDtor
2888           = dyn_cast<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) {
2889     QualType DestroyedType = PseudoDtor->getDestroyedType();
2890     if (getLangOpts().ObjCAutoRefCount &&
2891         DestroyedType->isObjCLifetimeType() &&
2892         (DestroyedType.getObjCLifetime() == Qualifiers::OCL_Strong ||
2893          DestroyedType.getObjCLifetime() == Qualifiers::OCL_Weak)) {
2894       // Automatic Reference Counting:
2895       //   If the pseudo-expression names a retainable object with weak or
2896       //   strong lifetime, the object shall be released.
2897       Expr *BaseExpr = PseudoDtor->getBase();
2898       llvm::Value *BaseValue = NULL;
2899       Qualifiers BaseQuals;
2900 
2901       // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
2902       if (PseudoDtor->isArrow()) {
2903         BaseValue = EmitScalarExpr(BaseExpr);
2904         const PointerType *PTy = BaseExpr->getType()->getAs<PointerType>();
2905         BaseQuals = PTy->getPointeeType().getQualifiers();
2906       } else {
2907         LValue BaseLV = EmitLValue(BaseExpr);
2908         BaseValue = BaseLV.getAddress();
2909         QualType BaseTy = BaseExpr->getType();
2910         BaseQuals = BaseTy.getQualifiers();
2911       }
2912 
2913       switch (PseudoDtor->getDestroyedType().getObjCLifetime()) {
2914       case Qualifiers::OCL_None:
2915       case Qualifiers::OCL_ExplicitNone:
2916       case Qualifiers::OCL_Autoreleasing:
2917         break;
2918 
2919       case Qualifiers::OCL_Strong:
2920         EmitARCRelease(Builder.CreateLoad(BaseValue,
2921                           PseudoDtor->getDestroyedType().isVolatileQualified()),
2922                        ARCPreciseLifetime);
2923         break;
2924 
2925       case Qualifiers::OCL_Weak:
2926         EmitARCDestroyWeak(BaseValue);
2927         break;
2928       }
2929     } else {
2930       // C++ [expr.pseudo]p1:
2931       //   The result shall only be used as the operand for the function call
2932       //   operator (), and the result of such a call has type void. The only
2933       //   effect is the evaluation of the postfix-expression before the dot or
2934       //   arrow.
2935       EmitScalarExpr(E->getCallee());
2936     }
2937 
2938     return RValue::get(0);
2939   }
2940 
2941   llvm::Value *Callee = EmitScalarExpr(E->getCallee());
2942   return EmitCall(E->getCallee()->getType(), Callee, ReturnValue,
2943                   E->arg_begin(), E->arg_end(), TargetDecl);
2944 }
2945 
EmitBinaryOperatorLValue(const BinaryOperator * E)2946 LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
2947   // Comma expressions just emit their LHS then their RHS as an l-value.
2948   if (E->getOpcode() == BO_Comma) {
2949     EmitIgnoredExpr(E->getLHS());
2950     EnsureInsertPoint();
2951     return EmitLValue(E->getRHS());
2952   }
2953 
2954   if (E->getOpcode() == BO_PtrMemD ||
2955       E->getOpcode() == BO_PtrMemI)
2956     return EmitPointerToDataMemberBinaryExpr(E);
2957 
2958   assert(E->getOpcode() == BO_Assign && "unexpected binary l-value");
2959 
2960   // Note that in all of these cases, __block variables need the RHS
2961   // evaluated first just in case the variable gets moved by the RHS.
2962 
2963   switch (getEvaluationKind(E->getType())) {
2964   case TEK_Scalar: {
2965     switch (E->getLHS()->getType().getObjCLifetime()) {
2966     case Qualifiers::OCL_Strong:
2967       return EmitARCStoreStrong(E, /*ignored*/ false).first;
2968 
2969     case Qualifiers::OCL_Autoreleasing:
2970       return EmitARCStoreAutoreleasing(E).first;
2971 
2972     // No reason to do any of these differently.
2973     case Qualifiers::OCL_None:
2974     case Qualifiers::OCL_ExplicitNone:
2975     case Qualifiers::OCL_Weak:
2976       break;
2977     }
2978 
2979     RValue RV = EmitAnyExpr(E->getRHS());
2980     LValue LV = EmitCheckedLValue(E->getLHS(), TCK_Store);
2981     EmitStoreThroughLValue(RV, LV);
2982     return LV;
2983   }
2984 
2985   case TEK_Complex:
2986     return EmitComplexAssignmentLValue(E);
2987 
2988   case TEK_Aggregate:
2989     return EmitAggExprToLValue(E);
2990   }
2991   llvm_unreachable("bad evaluation kind");
2992 }
2993 
EmitCallExprLValue(const CallExpr * E)2994 LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
2995   RValue RV = EmitCallExpr(E);
2996 
2997   if (!RV.isScalar())
2998     return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
2999 
3000   assert(E->getCallReturnType()->isReferenceType() &&
3001          "Can't have a scalar return unless the return type is a "
3002          "reference type!");
3003 
3004   return MakeAddrLValue(RV.getScalarVal(), E->getType());
3005 }
3006 
EmitVAArgExprLValue(const VAArgExpr * E)3007 LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
3008   // FIXME: This shouldn't require another copy.
3009   return EmitAggExprToLValue(E);
3010 }
3011 
EmitCXXConstructLValue(const CXXConstructExpr * E)3012 LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
3013   assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor()
3014          && "binding l-value to type which needs a temporary");
3015   AggValueSlot Slot = CreateAggTemp(E->getType());
3016   EmitCXXConstructExpr(E, Slot);
3017   return MakeAddrLValue(Slot.getAddr(), E->getType());
3018 }
3019 
3020 LValue
EmitCXXTypeidLValue(const CXXTypeidExpr * E)3021 CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) {
3022   return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType());
3023 }
3024 
EmitCXXUuidofExpr(const CXXUuidofExpr * E)3025 llvm::Value *CodeGenFunction::EmitCXXUuidofExpr(const CXXUuidofExpr *E) {
3026   return CGM.GetAddrOfUuidDescriptor(E);
3027 }
3028 
EmitCXXUuidofLValue(const CXXUuidofExpr * E)3029 LValue CodeGenFunction::EmitCXXUuidofLValue(const CXXUuidofExpr *E) {
3030   return MakeAddrLValue(EmitCXXUuidofExpr(E), E->getType());
3031 }
3032 
3033 LValue
EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr * E)3034 CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) {
3035   AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
3036   Slot.setExternallyDestructed();
3037   EmitAggExpr(E->getSubExpr(), Slot);
3038   EmitCXXTemporary(E->getTemporary(), E->getType(), Slot.getAddr());
3039   return MakeAddrLValue(Slot.getAddr(), E->getType());
3040 }
3041 
3042 LValue
EmitLambdaLValue(const LambdaExpr * E)3043 CodeGenFunction::EmitLambdaLValue(const LambdaExpr *E) {
3044   AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
3045   EmitLambdaExpr(E, Slot);
3046   return MakeAddrLValue(Slot.getAddr(), E->getType());
3047 }
3048 
EmitObjCMessageExprLValue(const ObjCMessageExpr * E)3049 LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
3050   RValue RV = EmitObjCMessageExpr(E);
3051 
3052   if (!RV.isScalar())
3053     return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
3054 
3055   assert(E->getMethodDecl()->getResultType()->isReferenceType() &&
3056          "Can't have a scalar return unless the return type is a "
3057          "reference type!");
3058 
3059   return MakeAddrLValue(RV.getScalarVal(), E->getType());
3060 }
3061 
EmitObjCSelectorLValue(const ObjCSelectorExpr * E)3062 LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) {
3063   llvm::Value *V =
3064     CGM.getObjCRuntime().GetSelector(*this, E->getSelector(), true);
3065   return MakeAddrLValue(V, E->getType());
3066 }
3067 
EmitIvarOffset(const ObjCInterfaceDecl * Interface,const ObjCIvarDecl * Ivar)3068 llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface,
3069                                              const ObjCIvarDecl *Ivar) {
3070   return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar);
3071 }
3072 
EmitLValueForIvar(QualType ObjectTy,llvm::Value * BaseValue,const ObjCIvarDecl * Ivar,unsigned CVRQualifiers)3073 LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
3074                                           llvm::Value *BaseValue,
3075                                           const ObjCIvarDecl *Ivar,
3076                                           unsigned CVRQualifiers) {
3077   return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue,
3078                                                    Ivar, CVRQualifiers);
3079 }
3080 
EmitObjCIvarRefLValue(const ObjCIvarRefExpr * E)3081 LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
3082   // FIXME: A lot of the code below could be shared with EmitMemberExpr.
3083   llvm::Value *BaseValue = 0;
3084   const Expr *BaseExpr = E->getBase();
3085   Qualifiers BaseQuals;
3086   QualType ObjectTy;
3087   if (E->isArrow()) {
3088     BaseValue = EmitScalarExpr(BaseExpr);
3089     ObjectTy = BaseExpr->getType()->getPointeeType();
3090     BaseQuals = ObjectTy.getQualifiers();
3091   } else {
3092     LValue BaseLV = EmitLValue(BaseExpr);
3093     // FIXME: this isn't right for bitfields.
3094     BaseValue = BaseLV.getAddress();
3095     ObjectTy = BaseExpr->getType();
3096     BaseQuals = ObjectTy.getQualifiers();
3097   }
3098 
3099   LValue LV =
3100     EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(),
3101                       BaseQuals.getCVRQualifiers());
3102   setObjCGCLValueClass(getContext(), E, LV);
3103   return LV;
3104 }
3105 
EmitStmtExprLValue(const StmtExpr * E)3106 LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
3107   // Can only get l-value for message expression returning aggregate type
3108   RValue RV = EmitAnyExprToTemp(E);
3109   return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
3110 }
3111 
EmitCall(QualType CalleeType,llvm::Value * Callee,ReturnValueSlot ReturnValue,CallExpr::const_arg_iterator ArgBeg,CallExpr::const_arg_iterator ArgEnd,const Decl * TargetDecl)3112 RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee,
3113                                  ReturnValueSlot ReturnValue,
3114                                  CallExpr::const_arg_iterator ArgBeg,
3115                                  CallExpr::const_arg_iterator ArgEnd,
3116                                  const Decl *TargetDecl) {
3117   // Get the actual function type. The callee type will always be a pointer to
3118   // function type or a block pointer type.
3119   assert(CalleeType->isFunctionPointerType() &&
3120          "Call must have function pointer type!");
3121 
3122   CalleeType = getContext().getCanonicalType(CalleeType);
3123 
3124   const FunctionType *FnType
3125     = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType());
3126 
3127   CallArgList Args;
3128   EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
3129 
3130   const CGFunctionInfo &FnInfo =
3131     CGM.getTypes().arrangeFreeFunctionCall(Args, FnType);
3132 
3133   // C99 6.5.2.2p6:
3134   //   If the expression that denotes the called function has a type
3135   //   that does not include a prototype, [the default argument
3136   //   promotions are performed]. If the number of arguments does not
3137   //   equal the number of parameters, the behavior is undefined. If
3138   //   the function is defined with a type that includes a prototype,
3139   //   and either the prototype ends with an ellipsis (, ...) or the
3140   //   types of the arguments after promotion are not compatible with
3141   //   the types of the parameters, the behavior is undefined. If the
3142   //   function is defined with a type that does not include a
3143   //   prototype, and the types of the arguments after promotion are
3144   //   not compatible with those of the parameters after promotion,
3145   //   the behavior is undefined [except in some trivial cases].
3146   // That is, in the general case, we should assume that a call
3147   // through an unprototyped function type works like a *non-variadic*
3148   // call.  The way we make this work is to cast to the exact type
3149   // of the promoted arguments.
3150   if (isa<FunctionNoProtoType>(FnType)) {
3151     llvm::Type *CalleeTy = getTypes().GetFunctionType(FnInfo);
3152     CalleeTy = CalleeTy->getPointerTo();
3153     Callee = Builder.CreateBitCast(Callee, CalleeTy, "callee.knr.cast");
3154   }
3155 
3156   return EmitCall(FnInfo, Callee, ReturnValue, Args, TargetDecl);
3157 }
3158 
3159 LValue CodeGenFunction::
EmitPointerToDataMemberBinaryExpr(const BinaryOperator * E)3160 EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
3161   llvm::Value *BaseV;
3162   if (E->getOpcode() == BO_PtrMemI)
3163     BaseV = EmitScalarExpr(E->getLHS());
3164   else
3165     BaseV = EmitLValue(E->getLHS()).getAddress();
3166 
3167   llvm::Value *OffsetV = EmitScalarExpr(E->getRHS());
3168 
3169   const MemberPointerType *MPT
3170     = E->getRHS()->getType()->getAs<MemberPointerType>();
3171 
3172   llvm::Value *AddV =
3173     CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT);
3174 
3175   return MakeAddrLValue(AddV, MPT->getPointeeType());
3176 }
3177 
3178 /// Given the address of a temporary variable, produce an r-value of
3179 /// its type.
convertTempToRValue(llvm::Value * addr,QualType type)3180 RValue CodeGenFunction::convertTempToRValue(llvm::Value *addr,
3181                                             QualType type) {
3182   LValue lvalue = MakeNaturalAlignAddrLValue(addr, type);
3183   switch (getEvaluationKind(type)) {
3184   case TEK_Complex:
3185     return RValue::getComplex(EmitLoadOfComplex(lvalue));
3186   case TEK_Aggregate:
3187     return lvalue.asAggregateRValue();
3188   case TEK_Scalar:
3189     return RValue::get(EmitLoadOfScalar(lvalue));
3190   }
3191   llvm_unreachable("bad evaluation kind");
3192 }
3193 
SetFPAccuracy(llvm::Value * Val,float Accuracy)3194 void CodeGenFunction::SetFPAccuracy(llvm::Value *Val, float Accuracy) {
3195   assert(Val->getType()->isFPOrFPVectorTy());
3196   if (Accuracy == 0.0 || !isa<llvm::Instruction>(Val))
3197     return;
3198 
3199   llvm::MDBuilder MDHelper(getLLVMContext());
3200   llvm::MDNode *Node = MDHelper.createFPMath(Accuracy);
3201 
3202   cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpmath, Node);
3203 }
3204 
3205 namespace {
3206   struct LValueOrRValue {
3207     LValue LV;
3208     RValue RV;
3209   };
3210 }
3211 
emitPseudoObjectExpr(CodeGenFunction & CGF,const PseudoObjectExpr * E,bool forLValue,AggValueSlot slot)3212 static LValueOrRValue emitPseudoObjectExpr(CodeGenFunction &CGF,
3213                                            const PseudoObjectExpr *E,
3214                                            bool forLValue,
3215                                            AggValueSlot slot) {
3216   SmallVector<CodeGenFunction::OpaqueValueMappingData, 4> opaques;
3217 
3218   // Find the result expression, if any.
3219   const Expr *resultExpr = E->getResultExpr();
3220   LValueOrRValue result;
3221 
3222   for (PseudoObjectExpr::const_semantics_iterator
3223          i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
3224     const Expr *semantic = *i;
3225 
3226     // If this semantic expression is an opaque value, bind it
3227     // to the result of its source expression.
3228     if (const OpaqueValueExpr *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
3229 
3230       // If this is the result expression, we may need to evaluate
3231       // directly into the slot.
3232       typedef CodeGenFunction::OpaqueValueMappingData OVMA;
3233       OVMA opaqueData;
3234       if (ov == resultExpr && ov->isRValue() && !forLValue &&
3235           CodeGenFunction::hasAggregateEvaluationKind(ov->getType())) {
3236         CGF.EmitAggExpr(ov->getSourceExpr(), slot);
3237 
3238         LValue LV = CGF.MakeAddrLValue(slot.getAddr(), ov->getType());
3239         opaqueData = OVMA::bind(CGF, ov, LV);
3240         result.RV = slot.asRValue();
3241 
3242       // Otherwise, emit as normal.
3243       } else {
3244         opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
3245 
3246         // If this is the result, also evaluate the result now.
3247         if (ov == resultExpr) {
3248           if (forLValue)
3249             result.LV = CGF.EmitLValue(ov);
3250           else
3251             result.RV = CGF.EmitAnyExpr(ov, slot);
3252         }
3253       }
3254 
3255       opaques.push_back(opaqueData);
3256 
3257     // Otherwise, if the expression is the result, evaluate it
3258     // and remember the result.
3259     } else if (semantic == resultExpr) {
3260       if (forLValue)
3261         result.LV = CGF.EmitLValue(semantic);
3262       else
3263         result.RV = CGF.EmitAnyExpr(semantic, slot);
3264 
3265     // Otherwise, evaluate the expression in an ignored context.
3266     } else {
3267       CGF.EmitIgnoredExpr(semantic);
3268     }
3269   }
3270 
3271   // Unbind all the opaques now.
3272   for (unsigned i = 0, e = opaques.size(); i != e; ++i)
3273     opaques[i].unbind(CGF);
3274 
3275   return result;
3276 }
3277 
EmitPseudoObjectRValue(const PseudoObjectExpr * E,AggValueSlot slot)3278 RValue CodeGenFunction::EmitPseudoObjectRValue(const PseudoObjectExpr *E,
3279                                                AggValueSlot slot) {
3280   return emitPseudoObjectExpr(*this, E, false, slot).RV;
3281 }
3282 
EmitPseudoObjectLValue(const PseudoObjectExpr * E)3283 LValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) {
3284   return emitPseudoObjectExpr(*this, E, true, AggValueSlot::ignored()).LV;
3285 }
3286