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