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