CGExpr.cpp revision 4c5d8afd100189b6cce4fd89bfb8aec5700acb50 
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().getLangOptions().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    return EmitCallExprLValue(cast<CallExpr>(E));
660  case Expr::VAArgExprClass:
661    return EmitVAArgExprLValue(cast<VAArgExpr>(E));
662  case Expr::DeclRefExprClass:
663    return EmitDeclRefLValue(cast<DeclRefExpr>(E));
664  case Expr::ParenExprClass:
665    return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
666  case Expr::GenericSelectionExprClass:
667    return EmitLValue(cast<GenericSelectionExpr>(E)->getResultExpr());
668  case Expr::PredefinedExprClass:
669    return EmitPredefinedLValue(cast<PredefinedExpr>(E));
670  case Expr::StringLiteralClass:
671    return EmitStringLiteralLValue(cast<StringLiteral>(E));
672  case Expr::ObjCEncodeExprClass:
673    return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E));
674  case Expr::PseudoObjectExprClass:
675    return EmitPseudoObjectLValue(cast<PseudoObjectExpr>(E));
676  case Expr::InitListExprClass:
677    assert(cast<InitListExpr>(E)->getNumInits() == 1 &&
678           "Only single-element init list can be lvalue.");
679    return EmitLValue(cast<InitListExpr>(E)->getInit(0));
680
681  case Expr::BlockDeclRefExprClass:
682    return EmitBlockDeclRefLValue(cast<BlockDeclRefExpr>(E));
683
684  case Expr::CXXTemporaryObjectExprClass:
685  case Expr::CXXConstructExprClass:
686    return EmitCXXConstructLValue(cast<CXXConstructExpr>(E));
687  case Expr::CXXBindTemporaryExprClass:
688    return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E));
689  case Expr::LambdaExprClass:
690    return EmitLambdaLValue(cast<LambdaExpr>(E));
691
692  case Expr::ExprWithCleanupsClass: {
693    const ExprWithCleanups *cleanups = cast<ExprWithCleanups>(E);
694    enterFullExpression(cleanups);
695    RunCleanupsScope Scope(*this);
696    return EmitLValue(cleanups->getSubExpr());
697  }
698
699  case Expr::CXXScalarValueInitExprClass:
700    return EmitNullInitializationLValue(cast<CXXScalarValueInitExpr>(E));
701  case Expr::CXXDefaultArgExprClass:
702    return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr());
703  case Expr::CXXTypeidExprClass:
704    return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E));
705
706  case Expr::ObjCMessageExprClass:
707    return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E));
708  case Expr::ObjCIvarRefExprClass:
709    return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E));
710  case Expr::StmtExprClass:
711    return EmitStmtExprLValue(cast<StmtExpr>(E));
712  case Expr::UnaryOperatorClass:
713    return EmitUnaryOpLValue(cast<UnaryOperator>(E));
714  case Expr::ArraySubscriptExprClass:
715    return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E));
716  case Expr::ExtVectorElementExprClass:
717    return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E));
718  case Expr::MemberExprClass:
719    return EmitMemberExpr(cast<MemberExpr>(E));
720  case Expr::CompoundLiteralExprClass:
721    return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E));
722  case Expr::ConditionalOperatorClass:
723    return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E));
724  case Expr::BinaryConditionalOperatorClass:
725    return EmitConditionalOperatorLValue(cast<BinaryConditionalOperator>(E));
726  case Expr::ChooseExprClass:
727    return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext()));
728  case Expr::OpaqueValueExprClass:
729    return EmitOpaqueValueLValue(cast<OpaqueValueExpr>(E));
730  case Expr::SubstNonTypeTemplateParmExprClass:
731    return EmitLValue(cast<SubstNonTypeTemplateParmExpr>(E)->getReplacement());
732  case Expr::ImplicitCastExprClass:
733  case Expr::CStyleCastExprClass:
734  case Expr::CXXFunctionalCastExprClass:
735  case Expr::CXXStaticCastExprClass:
736  case Expr::CXXDynamicCastExprClass:
737  case Expr::CXXReinterpretCastExprClass:
738  case Expr::CXXConstCastExprClass:
739  case Expr::ObjCBridgedCastExprClass:
740    return EmitCastLValue(cast<CastExpr>(E));
741
742  case Expr::MaterializeTemporaryExprClass:
743    return EmitMaterializeTemporaryExpr(cast<MaterializeTemporaryExpr>(E));
744  }
745}
746
747llvm::Value *CodeGenFunction::EmitLoadOfScalar(LValue lvalue) {
748  return EmitLoadOfScalar(lvalue.getAddress(), lvalue.isVolatile(),
749                          lvalue.getAlignment().getQuantity(),
750                          lvalue.getType(), lvalue.getTBAAInfo());
751}
752
753llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile,
754                                              unsigned Alignment, QualType Ty,
755                                              llvm::MDNode *TBAAInfo) {
756  llvm::LoadInst *Load = Builder.CreateLoad(Addr);
757  if (Volatile)
758    Load->setVolatile(true);
759  if (Alignment)
760    Load->setAlignment(Alignment);
761  if (TBAAInfo)
762    CGM.DecorateInstruction(Load, TBAAInfo);
763  // If this is an atomic type, all normal reads must be atomic
764  if (Ty->isAtomicType())
765    Load->setAtomic(llvm::SequentiallyConsistent);
766
767  return EmitFromMemory(Load, Ty);
768}
769
770static bool isBooleanUnderlyingType(QualType Ty) {
771  if (const EnumType *ET = dyn_cast<EnumType>(Ty))
772    return ET->getDecl()->getIntegerType()->isBooleanType();
773  return false;
774}
775
776llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) {
777  // Bool has a different representation in memory than in registers.
778  if (Ty->isBooleanType() || isBooleanUnderlyingType(Ty)) {
779    // This should really always be an i1, but sometimes it's already
780    // an i8, and it's awkward to track those cases down.
781    if (Value->getType()->isIntegerTy(1))
782      return Builder.CreateZExt(Value, Builder.getInt8Ty(), "frombool");
783    assert(Value->getType()->isIntegerTy(8) && "value rep of bool not i1/i8");
784  }
785
786  return Value;
787}
788
789llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) {
790  // Bool has a different representation in memory than in registers.
791  if (Ty->isBooleanType() || isBooleanUnderlyingType(Ty)) {
792    assert(Value->getType()->isIntegerTy(8) && "memory rep of bool not i8");
793    return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool");
794  }
795
796  return Value;
797}
798
799void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr,
800                                        bool Volatile, unsigned Alignment,
801                                        QualType Ty,
802                                        llvm::MDNode *TBAAInfo,
803                                        bool isInit) {
804  Value = EmitToMemory(Value, Ty);
805
806  llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile);
807  if (Alignment)
808    Store->setAlignment(Alignment);
809  if (TBAAInfo)
810    CGM.DecorateInstruction(Store, TBAAInfo);
811  if (!isInit && Ty->isAtomicType())
812    Store->setAtomic(llvm::SequentiallyConsistent);
813}
814
815void CodeGenFunction::EmitStoreOfScalar(llvm::Value *value, LValue lvalue,
816    bool isInit) {
817  EmitStoreOfScalar(value, lvalue.getAddress(), lvalue.isVolatile(),
818                    lvalue.getAlignment().getQuantity(), lvalue.getType(),
819                    lvalue.getTBAAInfo(), isInit);
820}
821
822/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this
823/// method emits the address of the lvalue, then loads the result as an rvalue,
824/// returning the rvalue.
825RValue CodeGenFunction::EmitLoadOfLValue(LValue LV) {
826  if (LV.isObjCWeak()) {
827    // load of a __weak object.
828    llvm::Value *AddrWeakObj = LV.getAddress();
829    return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this,
830                                                             AddrWeakObj));
831  }
832  if (LV.getQuals().getObjCLifetime() == Qualifiers::OCL_Weak)
833    return RValue::get(EmitARCLoadWeak(LV.getAddress()));
834
835  if (LV.isSimple()) {
836    assert(!LV.getType()->isFunctionType());
837
838    // Everything needs a load.
839    return RValue::get(EmitLoadOfScalar(LV));
840  }
841
842  if (LV.isVectorElt()) {
843    llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(),
844                                          LV.isVolatileQualified());
845    return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(),
846                                                    "vecext"));
847  }
848
849  // If this is a reference to a subset of the elements of a vector, either
850  // shuffle the input or extract/insert them as appropriate.
851  if (LV.isExtVectorElt())
852    return EmitLoadOfExtVectorElementLValue(LV);
853
854  assert(LV.isBitField() && "Unknown LValue type!");
855  return EmitLoadOfBitfieldLValue(LV);
856}
857
858RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV) {
859  const CGBitFieldInfo &Info = LV.getBitFieldInfo();
860
861  // Get the output type.
862  llvm::Type *ResLTy = ConvertType(LV.getType());
863  unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
864
865  // Compute the result as an OR of all of the individual component accesses.
866  llvm::Value *Res = 0;
867  for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
868    const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
869
870    // Get the field pointer.
871    llvm::Value *Ptr = LV.getBitFieldBaseAddr();
872
873    // Only offset by the field index if used, so that incoming values are not
874    // required to be structures.
875    if (AI.FieldIndex)
876      Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
877
878    // Offset by the byte offset, if used.
879    if (!AI.FieldByteOffset.isZero()) {
880      Ptr = EmitCastToVoidPtr(Ptr);
881      Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(),
882                                       "bf.field.offs");
883    }
884
885    // Cast to the access type.
886    llvm::Type *PTy = llvm::Type::getIntNPtrTy(getLLVMContext(), AI.AccessWidth,
887                       CGM.getContext().getTargetAddressSpace(LV.getType()));
888    Ptr = Builder.CreateBitCast(Ptr, PTy);
889
890    // Perform the load.
891    llvm::LoadInst *Load = Builder.CreateLoad(Ptr, LV.isVolatileQualified());
892    if (!AI.AccessAlignment.isZero())
893      Load->setAlignment(AI.AccessAlignment.getQuantity());
894
895    // Shift out unused low bits and mask out unused high bits.
896    llvm::Value *Val = Load;
897    if (AI.FieldBitStart)
898      Val = Builder.CreateLShr(Load, AI.FieldBitStart);
899    Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(AI.AccessWidth,
900                                                            AI.TargetBitWidth),
901                            "bf.clear");
902
903    // Extend or truncate to the target size.
904    if (AI.AccessWidth < ResSizeInBits)
905      Val = Builder.CreateZExt(Val, ResLTy);
906    else if (AI.AccessWidth > ResSizeInBits)
907      Val = Builder.CreateTrunc(Val, ResLTy);
908
909    // Shift into place, and OR into the result.
910    if (AI.TargetBitOffset)
911      Val = Builder.CreateShl(Val, AI.TargetBitOffset);
912    Res = Res ? Builder.CreateOr(Res, Val) : Val;
913  }
914
915  // If the bit-field is signed, perform the sign-extension.
916  //
917  // FIXME: This can easily be folded into the load of the high bits, which
918  // could also eliminate the mask of high bits in some situations.
919  if (Info.isSigned()) {
920    unsigned ExtraBits = ResSizeInBits - Info.getSize();
921    if (ExtraBits)
922      Res = Builder.CreateAShr(Builder.CreateShl(Res, ExtraBits),
923                               ExtraBits, "bf.val.sext");
924  }
925
926  return RValue::get(Res);
927}
928
929// If this is a reference to a subset of the elements of a vector, create an
930// appropriate shufflevector.
931RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV) {
932  llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(),
933                                        LV.isVolatileQualified());
934
935  const llvm::Constant *Elts = LV.getExtVectorElts();
936
937  // If the result of the expression is a non-vector type, we must be extracting
938  // a single element.  Just codegen as an extractelement.
939  const VectorType *ExprVT = LV.getType()->getAs<VectorType>();
940  if (!ExprVT) {
941    unsigned InIdx = getAccessedFieldNo(0, Elts);
942    llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
943    return RValue::get(Builder.CreateExtractElement(Vec, Elt));
944  }
945
946  // Always use shuffle vector to try to retain the original program structure
947  unsigned NumResultElts = ExprVT->getNumElements();
948
949  SmallVector<llvm::Constant*, 4> Mask;
950  for (unsigned i = 0; i != NumResultElts; ++i)
951    Mask.push_back(Builder.getInt32(getAccessedFieldNo(i, Elts)));
952
953  llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
954  Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()),
955                                    MaskV);
956  return RValue::get(Vec);
957}
958
959
960
961/// EmitStoreThroughLValue - Store the specified rvalue into the specified
962/// lvalue, where both are guaranteed to the have the same type, and that type
963/// is 'Ty'.
964void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, bool isInit) {
965  if (!Dst.isSimple()) {
966    if (Dst.isVectorElt()) {
967      // Read/modify/write the vector, inserting the new element.
968      llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(),
969                                            Dst.isVolatileQualified());
970      Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(),
971                                        Dst.getVectorIdx(), "vecins");
972      Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified());
973      return;
974    }
975
976    // If this is an update of extended vector elements, insert them as
977    // appropriate.
978    if (Dst.isExtVectorElt())
979      return EmitStoreThroughExtVectorComponentLValue(Src, Dst);
980
981    assert(Dst.isBitField() && "Unknown LValue type");
982    return EmitStoreThroughBitfieldLValue(Src, Dst);
983  }
984
985  // There's special magic for assigning into an ARC-qualified l-value.
986  if (Qualifiers::ObjCLifetime Lifetime = Dst.getQuals().getObjCLifetime()) {
987    switch (Lifetime) {
988    case Qualifiers::OCL_None:
989      llvm_unreachable("present but none");
990
991    case Qualifiers::OCL_ExplicitNone:
992      // nothing special
993      break;
994
995    case Qualifiers::OCL_Strong:
996      EmitARCStoreStrong(Dst, Src.getScalarVal(), /*ignore*/ true);
997      return;
998
999    case Qualifiers::OCL_Weak:
1000      EmitARCStoreWeak(Dst.getAddress(), Src.getScalarVal(), /*ignore*/ true);
1001      return;
1002
1003    case Qualifiers::OCL_Autoreleasing:
1004      Src = RValue::get(EmitObjCExtendObjectLifetime(Dst.getType(),
1005                                                     Src.getScalarVal()));
1006      // fall into the normal path
1007      break;
1008    }
1009  }
1010
1011  if (Dst.isObjCWeak() && !Dst.isNonGC()) {
1012    // load of a __weak object.
1013    llvm::Value *LvalueDst = Dst.getAddress();
1014    llvm::Value *src = Src.getScalarVal();
1015     CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst);
1016    return;
1017  }
1018
1019  if (Dst.isObjCStrong() && !Dst.isNonGC()) {
1020    // load of a __strong object.
1021    llvm::Value *LvalueDst = Dst.getAddress();
1022    llvm::Value *src = Src.getScalarVal();
1023    if (Dst.isObjCIvar()) {
1024      assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL");
1025      llvm::Type *ResultType = ConvertType(getContext().LongTy);
1026      llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp());
1027      llvm::Value *dst = RHS;
1028      RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
1029      llvm::Value *LHS =
1030        Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast");
1031      llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset");
1032      CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst,
1033                                              BytesBetween);
1034    } else if (Dst.isGlobalObjCRef()) {
1035      CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst,
1036                                                Dst.isThreadLocalRef());
1037    }
1038    else
1039      CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst);
1040    return;
1041  }
1042
1043  assert(Src.isScalar() && "Can't emit an agg store with this method");
1044  EmitStoreOfScalar(Src.getScalarVal(), Dst, isInit);
1045}
1046
1047void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst,
1048                                                     llvm::Value **Result) {
1049  const CGBitFieldInfo &Info = Dst.getBitFieldInfo();
1050
1051  // Get the output type.
1052  llvm::Type *ResLTy = ConvertTypeForMem(Dst.getType());
1053  unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy);
1054
1055  // Get the source value, truncated to the width of the bit-field.
1056  llvm::Value *SrcVal = Src.getScalarVal();
1057
1058  if (Dst.getType()->isBooleanType())
1059    SrcVal = Builder.CreateIntCast(SrcVal, ResLTy, /*IsSigned=*/false);
1060
1061  SrcVal = Builder.CreateAnd(SrcVal, llvm::APInt::getLowBitsSet(ResSizeInBits,
1062                                                                Info.getSize()),
1063                             "bf.value");
1064
1065  // Return the new value of the bit-field, if requested.
1066  if (Result) {
1067    // Cast back to the proper type for result.
1068    llvm::Type *SrcTy = Src.getScalarVal()->getType();
1069    llvm::Value *ReloadVal = Builder.CreateIntCast(SrcVal, SrcTy, false,
1070                                                   "bf.reload.val");
1071
1072    // Sign extend if necessary.
1073    if (Info.isSigned()) {
1074      unsigned ExtraBits = ResSizeInBits - Info.getSize();
1075      if (ExtraBits)
1076        ReloadVal = Builder.CreateAShr(Builder.CreateShl(ReloadVal, ExtraBits),
1077                                       ExtraBits, "bf.reload.sext");
1078    }
1079
1080    *Result = ReloadVal;
1081  }
1082
1083  // Iterate over the components, writing each piece to memory.
1084  for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) {
1085    const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i);
1086
1087    // Get the field pointer.
1088    llvm::Value *Ptr = Dst.getBitFieldBaseAddr();
1089    unsigned addressSpace =
1090      cast<llvm::PointerType>(Ptr->getType())->getAddressSpace();
1091
1092    // Only offset by the field index if used, so that incoming values are not
1093    // required to be structures.
1094    if (AI.FieldIndex)
1095      Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field");
1096
1097    // Offset by the byte offset, if used.
1098    if (!AI.FieldByteOffset.isZero()) {
1099      Ptr = EmitCastToVoidPtr(Ptr);
1100      Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset.getQuantity(),
1101                                       "bf.field.offs");
1102    }
1103
1104    // Cast to the access type.
1105    llvm::Type *AccessLTy =
1106      llvm::Type::getIntNTy(getLLVMContext(), AI.AccessWidth);
1107
1108    llvm::Type *PTy = AccessLTy->getPointerTo(addressSpace);
1109    Ptr = Builder.CreateBitCast(Ptr, PTy);
1110
1111    // Extract the piece of the bit-field value to write in this access, limited
1112    // to the values that are part of this access.
1113    llvm::Value *Val = SrcVal;
1114    if (AI.TargetBitOffset)
1115      Val = Builder.CreateLShr(Val, AI.TargetBitOffset);
1116    Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(ResSizeInBits,
1117                                                            AI.TargetBitWidth));
1118
1119    // Extend or truncate to the access size.
1120    if (ResSizeInBits < AI.AccessWidth)
1121      Val = Builder.CreateZExt(Val, AccessLTy);
1122    else if (ResSizeInBits > AI.AccessWidth)
1123      Val = Builder.CreateTrunc(Val, AccessLTy);
1124
1125    // Shift into the position in memory.
1126    if (AI.FieldBitStart)
1127      Val = Builder.CreateShl(Val, AI.FieldBitStart);
1128
1129    // If necessary, load and OR in bits that are outside of the bit-field.
1130    if (AI.TargetBitWidth != AI.AccessWidth) {
1131      llvm::LoadInst *Load = Builder.CreateLoad(Ptr, Dst.isVolatileQualified());
1132      if (!AI.AccessAlignment.isZero())
1133        Load->setAlignment(AI.AccessAlignment.getQuantity());
1134
1135      // Compute the mask for zeroing the bits that are part of the bit-field.
1136      llvm::APInt InvMask =
1137        ~llvm::APInt::getBitsSet(AI.AccessWidth, AI.FieldBitStart,
1138                                 AI.FieldBitStart + AI.TargetBitWidth);
1139
1140      // Apply the mask and OR in to the value to write.
1141      Val = Builder.CreateOr(Builder.CreateAnd(Load, InvMask), Val);
1142    }
1143
1144    // Write the value.
1145    llvm::StoreInst *Store = Builder.CreateStore(Val, Ptr,
1146                                                 Dst.isVolatileQualified());
1147    if (!AI.AccessAlignment.isZero())
1148      Store->setAlignment(AI.AccessAlignment.getQuantity());
1149  }
1150}
1151
1152void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src,
1153                                                               LValue Dst) {
1154  // This access turns into a read/modify/write of the vector.  Load the input
1155  // value now.
1156  llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(),
1157                                        Dst.isVolatileQualified());
1158  const llvm::Constant *Elts = Dst.getExtVectorElts();
1159
1160  llvm::Value *SrcVal = Src.getScalarVal();
1161
1162  if (const VectorType *VTy = Dst.getType()->getAs<VectorType>()) {
1163    unsigned NumSrcElts = VTy->getNumElements();
1164    unsigned NumDstElts =
1165       cast<llvm::VectorType>(Vec->getType())->getNumElements();
1166    if (NumDstElts == NumSrcElts) {
1167      // Use shuffle vector is the src and destination are the same number of
1168      // elements and restore the vector mask since it is on the side it will be
1169      // stored.
1170      SmallVector<llvm::Constant*, 4> Mask(NumDstElts);
1171      for (unsigned i = 0; i != NumSrcElts; ++i)
1172        Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i);
1173
1174      llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1175      Vec = Builder.CreateShuffleVector(SrcVal,
1176                                        llvm::UndefValue::get(Vec->getType()),
1177                                        MaskV);
1178    } else if (NumDstElts > NumSrcElts) {
1179      // Extended the source vector to the same length and then shuffle it
1180      // into the destination.
1181      // FIXME: since we're shuffling with undef, can we just use the indices
1182      //        into that?  This could be simpler.
1183      SmallVector<llvm::Constant*, 4> ExtMask;
1184      unsigned i;
1185      for (i = 0; i != NumSrcElts; ++i)
1186        ExtMask.push_back(Builder.getInt32(i));
1187      for (; i != NumDstElts; ++i)
1188        ExtMask.push_back(llvm::UndefValue::get(Int32Ty));
1189      llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask);
1190      llvm::Value *ExtSrcVal =
1191        Builder.CreateShuffleVector(SrcVal,
1192                                    llvm::UndefValue::get(SrcVal->getType()),
1193                                    ExtMaskV);
1194      // build identity
1195      SmallVector<llvm::Constant*, 4> Mask;
1196      for (unsigned i = 0; i != NumDstElts; ++i)
1197        Mask.push_back(Builder.getInt32(i));
1198
1199      // modify when what gets shuffled in
1200      for (unsigned i = 0; i != NumSrcElts; ++i)
1201        Mask[getAccessedFieldNo(i, Elts)] = Builder.getInt32(i+NumDstElts);
1202      llvm::Value *MaskV = llvm::ConstantVector::get(Mask);
1203      Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV);
1204    } else {
1205      // We should never shorten the vector
1206      llvm_unreachable("unexpected shorten vector length");
1207    }
1208  } else {
1209    // If the Src is a scalar (not a vector) it must be updating one element.
1210    unsigned InIdx = getAccessedFieldNo(0, Elts);
1211    llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx);
1212    Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt);
1213  }
1214
1215  Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified());
1216}
1217
1218// setObjCGCLValueClass - sets class of he lvalue for the purpose of
1219// generating write-barries API. It is currently a global, ivar,
1220// or neither.
1221static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E,
1222                                 LValue &LV,
1223                                 bool IsMemberAccess=false) {
1224  if (Ctx.getLangOptions().getGC() == LangOptions::NonGC)
1225    return;
1226
1227  if (isa<ObjCIvarRefExpr>(E)) {
1228    QualType ExpTy = E->getType();
1229    if (IsMemberAccess && ExpTy->isPointerType()) {
1230      // If ivar is a structure pointer, assigning to field of
1231      // this struct follows gcc's behavior and makes it a non-ivar
1232      // writer-barrier conservatively.
1233      ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1234      if (ExpTy->isRecordType()) {
1235        LV.setObjCIvar(false);
1236        return;
1237      }
1238    }
1239    LV.setObjCIvar(true);
1240    ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E));
1241    LV.setBaseIvarExp(Exp->getBase());
1242    LV.setObjCArray(E->getType()->isArrayType());
1243    return;
1244  }
1245
1246  if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) {
1247    if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) {
1248      if (VD->hasGlobalStorage()) {
1249        LV.setGlobalObjCRef(true);
1250        LV.setThreadLocalRef(VD->isThreadSpecified());
1251      }
1252    }
1253    LV.setObjCArray(E->getType()->isArrayType());
1254    return;
1255  }
1256
1257  if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) {
1258    setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
1259    return;
1260  }
1261
1262  if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) {
1263    setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
1264    if (LV.isObjCIvar()) {
1265      // If cast is to a structure pointer, follow gcc's behavior and make it
1266      // a non-ivar write-barrier.
1267      QualType ExpTy = E->getType();
1268      if (ExpTy->isPointerType())
1269        ExpTy = ExpTy->getAs<PointerType>()->getPointeeType();
1270      if (ExpTy->isRecordType())
1271        LV.setObjCIvar(false);
1272    }
1273    return;
1274  }
1275
1276  if (const GenericSelectionExpr *Exp = dyn_cast<GenericSelectionExpr>(E)) {
1277    setObjCGCLValueClass(Ctx, Exp->getResultExpr(), LV);
1278    return;
1279  }
1280
1281  if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) {
1282    setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
1283    return;
1284  }
1285
1286  if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) {
1287    setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
1288    return;
1289  }
1290
1291  if (const ObjCBridgedCastExpr *Exp = dyn_cast<ObjCBridgedCastExpr>(E)) {
1292    setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV, IsMemberAccess);
1293    return;
1294  }
1295
1296  if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) {
1297    setObjCGCLValueClass(Ctx, Exp->getBase(), LV);
1298    if (LV.isObjCIvar() && !LV.isObjCArray())
1299      // Using array syntax to assigning to what an ivar points to is not
1300      // same as assigning to the ivar itself. {id *Names;} Names[i] = 0;
1301      LV.setObjCIvar(false);
1302    else if (LV.isGlobalObjCRef() && !LV.isObjCArray())
1303      // Using array syntax to assigning to what global points to is not
1304      // same as assigning to the global itself. {id *G;} G[i] = 0;
1305      LV.setGlobalObjCRef(false);
1306    return;
1307  }
1308
1309  if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) {
1310    setObjCGCLValueClass(Ctx, Exp->getBase(), LV, true);
1311    // We don't know if member is an 'ivar', but this flag is looked at
1312    // only in the context of LV.isObjCIvar().
1313    LV.setObjCArray(E->getType()->isArrayType());
1314    return;
1315  }
1316}
1317
1318static llvm::Value *
1319EmitBitCastOfLValueToProperType(CodeGenFunction &CGF,
1320                                llvm::Value *V, llvm::Type *IRType,
1321                                StringRef Name = StringRef()) {
1322  unsigned AS = cast<llvm::PointerType>(V->getType())->getAddressSpace();
1323  return CGF.Builder.CreateBitCast(V, IRType->getPointerTo(AS), Name);
1324}
1325
1326static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF,
1327                                      const Expr *E, const VarDecl *VD) {
1328  assert((VD->hasExternalStorage() || VD->isFileVarDecl()) &&
1329         "Var decl must have external storage or be a file var decl!");
1330
1331  llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD);
1332  llvm::Type *RealVarTy = CGF.getTypes().ConvertTypeForMem(VD->getType());
1333  V = EmitBitCastOfLValueToProperType(CGF, V, RealVarTy);
1334  CharUnits Alignment = CGF.getContext().getDeclAlign(VD);
1335  QualType T = E->getType();
1336  LValue LV;
1337  if (VD->getType()->isReferenceType()) {
1338    llvm::LoadInst *LI = CGF.Builder.CreateLoad(V);
1339    LI->setAlignment(Alignment.getQuantity());
1340    V = LI;
1341    LV = CGF.MakeNaturalAlignAddrLValue(V, T);
1342  } else {
1343    LV = CGF.MakeAddrLValue(V, E->getType(), Alignment);
1344  }
1345  setObjCGCLValueClass(CGF.getContext(), E, LV);
1346  return LV;
1347}
1348
1349static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF,
1350                                     const Expr *E, const FunctionDecl *FD) {
1351  llvm::Value *V = CGF.CGM.GetAddrOfFunction(FD);
1352  if (!FD->hasPrototype()) {
1353    if (const FunctionProtoType *Proto =
1354            FD->getType()->getAs<FunctionProtoType>()) {
1355      // Ugly case: for a K&R-style definition, the type of the definition
1356      // isn't the same as the type of a use.  Correct for this with a
1357      // bitcast.
1358      QualType NoProtoType =
1359          CGF.getContext().getFunctionNoProtoType(Proto->getResultType());
1360      NoProtoType = CGF.getContext().getPointerType(NoProtoType);
1361      V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType));
1362    }
1363  }
1364  CharUnits Alignment = CGF.getContext().getDeclAlign(FD);
1365  return CGF.MakeAddrLValue(V, E->getType(), Alignment);
1366}
1367
1368LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) {
1369  const NamedDecl *ND = E->getDecl();
1370  CharUnits Alignment = getContext().getDeclAlign(ND);
1371  QualType T = E->getType();
1372
1373  // FIXME: We should be able to assert this for FunctionDecls as well!
1374  // FIXME: We should be able to assert this for all DeclRefExprs, not just
1375  // those with a valid source location.
1376  assert((ND->isUsed(false) || !isa<VarDecl>(ND) ||
1377          !E->getLocation().isValid()) &&
1378         "Should not use decl without marking it used!");
1379
1380  if (ND->hasAttr<WeakRefAttr>()) {
1381    const ValueDecl *VD = cast<ValueDecl>(ND);
1382    llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD);
1383    return MakeAddrLValue(Aliasee, E->getType(), Alignment);
1384  }
1385
1386  if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) {
1387
1388    // Check if this is a global variable.
1389    if (VD->hasExternalStorage() || VD->isFileVarDecl())
1390      return EmitGlobalVarDeclLValue(*this, E, VD);
1391
1392    bool NonGCable = VD->hasLocalStorage() &&
1393                     !VD->getType()->isReferenceType() &&
1394                     !VD->hasAttr<BlocksAttr>();
1395
1396    llvm::Value *V = LocalDeclMap[VD];
1397    if (!V && VD->isStaticLocal())
1398      V = CGM.getStaticLocalDeclAddress(VD);
1399    assert(V && "DeclRefExpr not entered in LocalDeclMap?");
1400
1401    if (VD->hasAttr<BlocksAttr>())
1402      V = BuildBlockByrefAddress(V, VD);
1403
1404    LValue LV;
1405    if (VD->getType()->isReferenceType()) {
1406      llvm::LoadInst *LI = Builder.CreateLoad(V);
1407      LI->setAlignment(Alignment.getQuantity());
1408      V = LI;
1409      LV = MakeNaturalAlignAddrLValue(V, T);
1410    } else {
1411      LV = MakeAddrLValue(V, T, Alignment);
1412    }
1413
1414    if (NonGCable) {
1415      LV.getQuals().removeObjCGCAttr();
1416      LV.setNonGC(true);
1417    }
1418    setObjCGCLValueClass(getContext(), E, LV);
1419    return LV;
1420  }
1421
1422  if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND))
1423    return EmitFunctionDeclLValue(*this, E, fn);
1424
1425  llvm_unreachable("Unhandled DeclRefExpr");
1426}
1427
1428LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) {
1429  CharUnits Alignment = getContext().getDeclAlign(E->getDecl());
1430  return MakeAddrLValue(GetAddrOfBlockDecl(E), E->getType(), Alignment);
1431}
1432
1433LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) {
1434  // __extension__ doesn't affect lvalue-ness.
1435  if (E->getOpcode() == UO_Extension)
1436    return EmitLValue(E->getSubExpr());
1437
1438  QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType());
1439  switch (E->getOpcode()) {
1440  default: llvm_unreachable("Unknown unary operator lvalue!");
1441  case UO_Deref: {
1442    QualType T = E->getSubExpr()->getType()->getPointeeType();
1443    assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type");
1444
1445    LValue LV = MakeNaturalAlignAddrLValue(EmitScalarExpr(E->getSubExpr()), T);
1446    LV.getQuals().setAddressSpace(ExprTy.getAddressSpace());
1447
1448    // We should not generate __weak write barrier on indirect reference
1449    // of a pointer to object; as in void foo (__weak id *param); *param = 0;
1450    // But, we continue to generate __strong write barrier on indirect write
1451    // into a pointer to object.
1452    if (getContext().getLangOptions().ObjC1 &&
1453        getContext().getLangOptions().getGC() != LangOptions::NonGC &&
1454        LV.isObjCWeak())
1455      LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
1456    return LV;
1457  }
1458  case UO_Real:
1459  case UO_Imag: {
1460    LValue LV = EmitLValue(E->getSubExpr());
1461    assert(LV.isSimple() && "real/imag on non-ordinary l-value");
1462    llvm::Value *Addr = LV.getAddress();
1463
1464    // real and imag are valid on scalars.  This is a faster way of
1465    // testing that.
1466    if (!cast<llvm::PointerType>(Addr->getType())
1467           ->getElementType()->isStructTy()) {
1468      assert(E->getSubExpr()->getType()->isArithmeticType());
1469      return LV;
1470    }
1471
1472    assert(E->getSubExpr()->getType()->isAnyComplexType());
1473
1474    unsigned Idx = E->getOpcode() == UO_Imag;
1475    return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(),
1476                                                  Idx, "idx"),
1477                          ExprTy);
1478  }
1479  case UO_PreInc:
1480  case UO_PreDec: {
1481    LValue LV = EmitLValue(E->getSubExpr());
1482    bool isInc = E->getOpcode() == UO_PreInc;
1483
1484    if (E->getType()->isAnyComplexType())
1485      EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/);
1486    else
1487      EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/);
1488    return LV;
1489  }
1490  }
1491}
1492
1493LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) {
1494  return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E),
1495                        E->getType());
1496}
1497
1498LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) {
1499  return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E),
1500                        E->getType());
1501}
1502
1503
1504LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) {
1505  switch (E->getIdentType()) {
1506  default:
1507    return EmitUnsupportedLValue(E, "predefined expression");
1508
1509  case PredefinedExpr::Func:
1510  case PredefinedExpr::Function:
1511  case PredefinedExpr::PrettyFunction: {
1512    unsigned Type = E->getIdentType();
1513    std::string GlobalVarName;
1514
1515    switch (Type) {
1516    default: llvm_unreachable("Invalid type");
1517    case PredefinedExpr::Func:
1518      GlobalVarName = "__func__.";
1519      break;
1520    case PredefinedExpr::Function:
1521      GlobalVarName = "__FUNCTION__.";
1522      break;
1523    case PredefinedExpr::PrettyFunction:
1524      GlobalVarName = "__PRETTY_FUNCTION__.";
1525      break;
1526    }
1527
1528    StringRef FnName = CurFn->getName();
1529    if (FnName.startswith("\01"))
1530      FnName = FnName.substr(1);
1531    GlobalVarName += FnName;
1532
1533    const Decl *CurDecl = CurCodeDecl;
1534    if (CurDecl == 0)
1535      CurDecl = getContext().getTranslationUnitDecl();
1536
1537    std::string FunctionName =
1538        (isa<BlockDecl>(CurDecl)
1539         ? FnName.str()
1540         : PredefinedExpr::ComputeName((PredefinedExpr::IdentType)Type, CurDecl));
1541
1542    llvm::Constant *C =
1543      CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str());
1544    return MakeAddrLValue(C, E->getType());
1545  }
1546  }
1547}
1548
1549llvm::BasicBlock *CodeGenFunction::getTrapBB() {
1550  const CodeGenOptions &GCO = CGM.getCodeGenOpts();
1551
1552  // If we are not optimzing, don't collapse all calls to trap in the function
1553  // to the same call, that way, in the debugger they can see which operation
1554  // did in fact fail.  If we are optimizing, we collapse all calls to trap down
1555  // to just one per function to save on codesize.
1556  if (GCO.OptimizationLevel && TrapBB)
1557    return TrapBB;
1558
1559  llvm::BasicBlock *Cont = 0;
1560  if (HaveInsertPoint()) {
1561    Cont = createBasicBlock("cont");
1562    EmitBranch(Cont);
1563  }
1564  TrapBB = createBasicBlock("trap");
1565  EmitBlock(TrapBB);
1566
1567  llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap);
1568  llvm::CallInst *TrapCall = Builder.CreateCall(F);
1569  TrapCall->setDoesNotReturn();
1570  TrapCall->setDoesNotThrow();
1571  Builder.CreateUnreachable();
1572
1573  if (Cont)
1574    EmitBlock(Cont);
1575  return TrapBB;
1576}
1577
1578/// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an
1579/// array to pointer, return the array subexpression.
1580static const Expr *isSimpleArrayDecayOperand(const Expr *E) {
1581  // If this isn't just an array->pointer decay, bail out.
1582  const CastExpr *CE = dyn_cast<CastExpr>(E);
1583  if (CE == 0 || CE->getCastKind() != CK_ArrayToPointerDecay)
1584    return 0;
1585
1586  // If this is a decay from variable width array, bail out.
1587  const Expr *SubExpr = CE->getSubExpr();
1588  if (SubExpr->getType()->isVariableArrayType())
1589    return 0;
1590
1591  return SubExpr;
1592}
1593
1594LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) {
1595  // The index must always be an integer, which is not an aggregate.  Emit it.
1596  llvm::Value *Idx = EmitScalarExpr(E->getIdx());
1597  QualType IdxTy  = E->getIdx()->getType();
1598  bool IdxSigned = IdxTy->isSignedIntegerOrEnumerationType();
1599
1600  // If the base is a vector type, then we are forming a vector element lvalue
1601  // with this subscript.
1602  if (E->getBase()->getType()->isVectorType()) {
1603    // Emit the vector as an lvalue to get its address.
1604    LValue LHS = EmitLValue(E->getBase());
1605    assert(LHS.isSimple() && "Can only subscript lvalue vectors here!");
1606    Idx = Builder.CreateIntCast(Idx, Int32Ty, IdxSigned, "vidx");
1607    return LValue::MakeVectorElt(LHS.getAddress(), Idx,
1608                                 E->getBase()->getType());
1609  }
1610
1611  // Extend or truncate the index type to 32 or 64-bits.
1612  if (Idx->getType() != IntPtrTy)
1613    Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom");
1614
1615  // FIXME: As llvm implements the object size checking, this can come out.
1616  if (CatchUndefined) {
1617    if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E->getBase())){
1618      if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) {
1619        if (ICE->getCastKind() == CK_ArrayToPointerDecay) {
1620          if (const ConstantArrayType *CAT
1621              = getContext().getAsConstantArrayType(DRE->getType())) {
1622            llvm::APInt Size = CAT->getSize();
1623            llvm::BasicBlock *Cont = createBasicBlock("cont");
1624            Builder.CreateCondBr(Builder.CreateICmpULE(Idx,
1625                                  llvm::ConstantInt::get(Idx->getType(), Size)),
1626                                 Cont, getTrapBB());
1627            EmitBlock(Cont);
1628          }
1629        }
1630      }
1631    }
1632  }
1633
1634  // We know that the pointer points to a type of the correct size, unless the
1635  // size is a VLA or Objective-C interface.
1636  llvm::Value *Address = 0;
1637  CharUnits ArrayAlignment;
1638  if (const VariableArrayType *vla =
1639        getContext().getAsVariableArrayType(E->getType())) {
1640    // The base must be a pointer, which is not an aggregate.  Emit
1641    // it.  It needs to be emitted first in case it's what captures
1642    // the VLA bounds.
1643    Address = EmitScalarExpr(E->getBase());
1644
1645    // The element count here is the total number of non-VLA elements.
1646    llvm::Value *numElements = getVLASize(vla).first;
1647
1648    // Effectively, the multiply by the VLA size is part of the GEP.
1649    // GEP indexes are signed, and scaling an index isn't permitted to
1650    // signed-overflow, so we use the same semantics for our explicit
1651    // multiply.  We suppress this if overflow is not undefined behavior.
1652    if (getLangOptions().isSignedOverflowDefined()) {
1653      Idx = Builder.CreateMul(Idx, numElements);
1654      Address = Builder.CreateGEP(Address, Idx, "arrayidx");
1655    } else {
1656      Idx = Builder.CreateNSWMul(Idx, numElements);
1657      Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx");
1658    }
1659  } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){
1660    // Indexing over an interface, as in "NSString *P; P[4];"
1661    llvm::Value *InterfaceSize =
1662      llvm::ConstantInt::get(Idx->getType(),
1663          getContext().getTypeSizeInChars(OIT).getQuantity());
1664
1665    Idx = Builder.CreateMul(Idx, InterfaceSize);
1666
1667    // The base must be a pointer, which is not an aggregate.  Emit it.
1668    llvm::Value *Base = EmitScalarExpr(E->getBase());
1669    Address = EmitCastToVoidPtr(Base);
1670    Address = Builder.CreateGEP(Address, Idx, "arrayidx");
1671    Address = Builder.CreateBitCast(Address, Base->getType());
1672  } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) {
1673    // If this is A[i] where A is an array, the frontend will have decayed the
1674    // base to be a ArrayToPointerDecay implicit cast.  While correct, it is
1675    // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a
1676    // "gep x, i" here.  Emit one "gep A, 0, i".
1677    assert(Array->getType()->isArrayType() &&
1678           "Array to pointer decay must have array source type!");
1679    LValue ArrayLV = EmitLValue(Array);
1680    llvm::Value *ArrayPtr = ArrayLV.getAddress();
1681    llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0);
1682    llvm::Value *Args[] = { Zero, Idx };
1683
1684    // Propagate the alignment from the array itself to the result.
1685    ArrayAlignment = ArrayLV.getAlignment();
1686
1687    if (getContext().getLangOptions().isSignedOverflowDefined())
1688      Address = Builder.CreateGEP(ArrayPtr, Args, "arrayidx");
1689    else
1690      Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, "arrayidx");
1691  } else {
1692    // The base must be a pointer, which is not an aggregate.  Emit it.
1693    llvm::Value *Base = EmitScalarExpr(E->getBase());
1694    if (getContext().getLangOptions().isSignedOverflowDefined())
1695      Address = Builder.CreateGEP(Base, Idx, "arrayidx");
1696    else
1697      Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx");
1698  }
1699
1700  QualType T = E->getBase()->getType()->getPointeeType();
1701  assert(!T.isNull() &&
1702         "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type");
1703
1704
1705  // Limit the alignment to that of the result type.
1706  LValue LV;
1707  if (!ArrayAlignment.isZero()) {
1708    CharUnits Align = getContext().getTypeAlignInChars(T);
1709    ArrayAlignment = std::min(Align, ArrayAlignment);
1710    LV = MakeAddrLValue(Address, T, ArrayAlignment);
1711  } else {
1712    LV = MakeNaturalAlignAddrLValue(Address, T);
1713  }
1714
1715  LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace());
1716
1717  if (getContext().getLangOptions().ObjC1 &&
1718      getContext().getLangOptions().getGC() != LangOptions::NonGC) {
1719    LV.setNonGC(!E->isOBJCGCCandidate(getContext()));
1720    setObjCGCLValueClass(getContext(), E, LV);
1721  }
1722  return LV;
1723}
1724
1725static
1726llvm::Constant *GenerateConstantVector(CGBuilderTy &Builder,
1727                                       SmallVector<unsigned, 4> &Elts) {
1728  SmallVector<llvm::Constant*, 4> CElts;
1729  for (unsigned i = 0, e = Elts.size(); i != e; ++i)
1730    CElts.push_back(Builder.getInt32(Elts[i]));
1731
1732  return llvm::ConstantVector::get(CElts);
1733}
1734
1735LValue CodeGenFunction::
1736EmitExtVectorElementExpr(const ExtVectorElementExpr *E) {
1737  // Emit the base vector as an l-value.
1738  LValue Base;
1739
1740  // ExtVectorElementExpr's base can either be a vector or pointer to vector.
1741  if (E->isArrow()) {
1742    // If it is a pointer to a vector, emit the address and form an lvalue with
1743    // it.
1744    llvm::Value *Ptr = EmitScalarExpr(E->getBase());
1745    const PointerType *PT = E->getBase()->getType()->getAs<PointerType>();
1746    Base = MakeAddrLValue(Ptr, PT->getPointeeType());
1747    Base.getQuals().removeObjCGCAttr();
1748  } else if (E->getBase()->isGLValue()) {
1749    // Otherwise, if the base is an lvalue ( as in the case of foo.x.x),
1750    // emit the base as an lvalue.
1751    assert(E->getBase()->getType()->isVectorType());
1752    Base = EmitLValue(E->getBase());
1753  } else {
1754    // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such.
1755    assert(E->getBase()->getType()->isVectorType() &&
1756           "Result must be a vector");
1757    llvm::Value *Vec = EmitScalarExpr(E->getBase());
1758
1759    // Store the vector to memory (because LValue wants an address).
1760    llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType());
1761    Builder.CreateStore(Vec, VecMem);
1762    Base = MakeAddrLValue(VecMem, E->getBase()->getType());
1763  }
1764
1765  QualType type =
1766    E->getType().withCVRQualifiers(Base.getQuals().getCVRQualifiers());
1767
1768  // Encode the element access list into a vector of unsigned indices.
1769  SmallVector<unsigned, 4> Indices;
1770  E->getEncodedElementAccess(Indices);
1771
1772  if (Base.isSimple()) {
1773    llvm::Constant *CV = GenerateConstantVector(Builder, Indices);
1774    return LValue::MakeExtVectorElt(Base.getAddress(), CV, type);
1775  }
1776  assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!");
1777
1778  llvm::Constant *BaseElts = Base.getExtVectorElts();
1779  SmallVector<llvm::Constant *, 4> CElts;
1780
1781  for (unsigned i = 0, e = Indices.size(); i != e; ++i)
1782    CElts.push_back(BaseElts->getAggregateElement(Indices[i]));
1783  llvm::Constant *CV = llvm::ConstantVector::get(CElts);
1784  return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, type);
1785}
1786
1787LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) {
1788  bool isNonGC = false;
1789  Expr *BaseExpr = E->getBase();
1790  llvm::Value *BaseValue = NULL;
1791  Qualifiers BaseQuals;
1792
1793  // If this is s.x, emit s as an lvalue.  If it is s->x, emit s as a scalar.
1794  if (E->isArrow()) {
1795    BaseValue = EmitScalarExpr(BaseExpr);
1796    const PointerType *PTy =
1797      BaseExpr->getType()->getAs<PointerType>();
1798    BaseQuals = PTy->getPointeeType().getQualifiers();
1799  } else {
1800    LValue BaseLV = EmitLValue(BaseExpr);
1801    if (BaseLV.isNonGC())
1802      isNonGC = true;
1803    // FIXME: this isn't right for bitfields.
1804    BaseValue = BaseLV.getAddress();
1805    QualType BaseTy = BaseExpr->getType();
1806    BaseQuals = BaseTy.getQualifiers();
1807  }
1808
1809  NamedDecl *ND = E->getMemberDecl();
1810  if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) {
1811    LValue LV = EmitLValueForField(BaseValue, Field,
1812                                   BaseQuals.getCVRQualifiers());
1813    LV.setNonGC(isNonGC);
1814    setObjCGCLValueClass(getContext(), E, LV);
1815    return LV;
1816  }
1817
1818  if (VarDecl *VD = dyn_cast<VarDecl>(ND))
1819    return EmitGlobalVarDeclLValue(*this, E, VD);
1820
1821  if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND))
1822    return EmitFunctionDeclLValue(*this, E, FD);
1823
1824  llvm_unreachable("Unhandled member declaration!");
1825}
1826
1827LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value *BaseValue,
1828                                              const FieldDecl *Field,
1829                                              unsigned CVRQualifiers) {
1830  const CGRecordLayout &RL =
1831    CGM.getTypes().getCGRecordLayout(Field->getParent());
1832  const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field);
1833  return LValue::MakeBitfield(BaseValue, Info,
1834                          Field->getType().withCVRQualifiers(CVRQualifiers));
1835}
1836
1837/// EmitLValueForAnonRecordField - Given that the field is a member of
1838/// an anonymous struct or union buried inside a record, and given
1839/// that the base value is a pointer to the enclosing record, derive
1840/// an lvalue for the ultimate field.
1841LValue CodeGenFunction::EmitLValueForAnonRecordField(llvm::Value *BaseValue,
1842                                             const IndirectFieldDecl *Field,
1843                                                     unsigned CVRQualifiers) {
1844  IndirectFieldDecl::chain_iterator I = Field->chain_begin(),
1845    IEnd = Field->chain_end();
1846  while (true) {
1847    LValue LV = EmitLValueForField(BaseValue, cast<FieldDecl>(*I),
1848                                   CVRQualifiers);
1849    if (++I == IEnd) return LV;
1850
1851    assert(LV.isSimple());
1852    BaseValue = LV.getAddress();
1853    CVRQualifiers |= LV.getVRQualifiers();
1854  }
1855}
1856
1857LValue CodeGenFunction::EmitLValueForField(llvm::Value *baseAddr,
1858                                           const FieldDecl *field,
1859                                           unsigned cvr) {
1860  if (field->isBitField())
1861    return EmitLValueForBitfield(baseAddr, field, cvr);
1862
1863  const RecordDecl *rec = field->getParent();
1864  QualType type = field->getType();
1865  CharUnits alignment = getContext().getDeclAlign(field);
1866
1867  bool mayAlias = rec->hasAttr<MayAliasAttr>();
1868
1869  llvm::Value *addr = baseAddr;
1870  if (rec->isUnion()) {
1871    // For unions, there is no pointer adjustment.
1872    assert(!type->isReferenceType() && "union has reference member");
1873  } else {
1874    // For structs, we GEP to the field that the record layout suggests.
1875    unsigned idx = CGM.getTypes().getCGRecordLayout(rec).getLLVMFieldNo(field);
1876    addr = Builder.CreateStructGEP(addr, idx, field->getName());
1877
1878    // If this is a reference field, load the reference right now.
1879    if (const ReferenceType *refType = type->getAs<ReferenceType>()) {
1880      llvm::LoadInst *load = Builder.CreateLoad(addr, "ref");
1881      if (cvr & Qualifiers::Volatile) load->setVolatile(true);
1882      load->setAlignment(alignment.getQuantity());
1883
1884      if (CGM.shouldUseTBAA()) {
1885        llvm::MDNode *tbaa;
1886        if (mayAlias)
1887          tbaa = CGM.getTBAAInfo(getContext().CharTy);
1888        else
1889          tbaa = CGM.getTBAAInfo(type);
1890        CGM.DecorateInstruction(load, tbaa);
1891      }
1892
1893      addr = load;
1894      mayAlias = false;
1895      type = refType->getPointeeType();
1896      if (type->isIncompleteType())
1897        alignment = CharUnits();
1898      else
1899        alignment = getContext().getTypeAlignInChars(type);
1900      cvr = 0; // qualifiers don't recursively apply to referencee
1901    }
1902  }
1903
1904  // Make sure that the address is pointing to the right type.  This is critical
1905  // for both unions and structs.  A union needs a bitcast, a struct element
1906  // will need a bitcast if the LLVM type laid out doesn't match the desired
1907  // type.
1908  addr = EmitBitCastOfLValueToProperType(*this, addr,
1909                                         CGM.getTypes().ConvertTypeForMem(type),
1910                                         field->getName());
1911
1912  if (field->hasAttr<AnnotateAttr>())
1913    addr = EmitFieldAnnotations(field, addr);
1914
1915  LValue LV = MakeAddrLValue(addr, type, alignment);
1916  LV.getQuals().addCVRQualifiers(cvr);
1917
1918  // __weak attribute on a field is ignored.
1919  if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak)
1920    LV.getQuals().removeObjCGCAttr();
1921
1922  // Fields of may_alias structs act like 'char' for TBAA purposes.
1923  // FIXME: this should get propagated down through anonymous structs
1924  // and unions.
1925  if (mayAlias && LV.getTBAAInfo())
1926    LV.setTBAAInfo(CGM.getTBAAInfo(getContext().CharTy));
1927
1928  return LV;
1929}
1930
1931LValue
1932CodeGenFunction::EmitLValueForFieldInitialization(llvm::Value *BaseValue,
1933                                                  const FieldDecl *Field,
1934                                                  unsigned CVRQualifiers) {
1935  QualType FieldType = Field->getType();
1936
1937  if (!FieldType->isReferenceType())
1938    return EmitLValueForField(BaseValue, Field, CVRQualifiers);
1939
1940  const CGRecordLayout &RL =
1941    CGM.getTypes().getCGRecordLayout(Field->getParent());
1942  unsigned idx = RL.getLLVMFieldNo(Field);
1943  llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx);
1944  assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs");
1945
1946
1947  // Make sure that the address is pointing to the right type.  This is critical
1948  // for both unions and structs.  A union needs a bitcast, a struct element
1949  // will need a bitcast if the LLVM type laid out doesn't match the desired
1950  // type.
1951  llvm::Type *llvmType = ConvertTypeForMem(FieldType);
1952  unsigned AS = cast<llvm::PointerType>(V->getType())->getAddressSpace();
1953  V = Builder.CreateBitCast(V, llvmType->getPointerTo(AS));
1954
1955  CharUnits Alignment = getContext().getDeclAlign(Field);
1956  return MakeAddrLValue(V, FieldType, Alignment);
1957}
1958
1959LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){
1960  if (E->isFileScope()) {
1961    llvm::Value *GlobalPtr = CGM.GetAddrOfConstantCompoundLiteral(E);
1962    return MakeAddrLValue(GlobalPtr, E->getType());
1963  }
1964
1965  llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral");
1966  const Expr *InitExpr = E->getInitializer();
1967  LValue Result = MakeAddrLValue(DeclPtr, E->getType());
1968
1969  EmitAnyExprToMem(InitExpr, DeclPtr, E->getType().getQualifiers(),
1970                   /*Init*/ true);
1971
1972  return Result;
1973}
1974
1975LValue CodeGenFunction::
1976EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) {
1977  if (!expr->isGLValue()) {
1978    // ?: here should be an aggregate.
1979    assert((hasAggregateLLVMType(expr->getType()) &&
1980            !expr->getType()->isAnyComplexType()) &&
1981           "Unexpected conditional operator!");
1982    return EmitAggExprToLValue(expr);
1983  }
1984
1985  OpaqueValueMapping binding(*this, expr);
1986
1987  const Expr *condExpr = expr->getCond();
1988  bool CondExprBool;
1989  if (ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) {
1990    const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr();
1991    if (!CondExprBool) std::swap(live, dead);
1992
1993    if (!ContainsLabel(dead))
1994      return EmitLValue(live);
1995  }
1996
1997  llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true");
1998  llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false");
1999  llvm::BasicBlock *contBlock = createBasicBlock("cond.end");
2000
2001  ConditionalEvaluation eval(*this);
2002  EmitBranchOnBoolExpr(condExpr, lhsBlock, rhsBlock);
2003
2004  // Any temporaries created here are conditional.
2005  EmitBlock(lhsBlock);
2006  eval.begin(*this);
2007  LValue lhs = EmitLValue(expr->getTrueExpr());
2008  eval.end(*this);
2009
2010  if (!lhs.isSimple())
2011    return EmitUnsupportedLValue(expr, "conditional operator");
2012
2013  lhsBlock = Builder.GetInsertBlock();
2014  Builder.CreateBr(contBlock);
2015
2016  // Any temporaries created here are conditional.
2017  EmitBlock(rhsBlock);
2018  eval.begin(*this);
2019  LValue rhs = EmitLValue(expr->getFalseExpr());
2020  eval.end(*this);
2021  if (!rhs.isSimple())
2022    return EmitUnsupportedLValue(expr, "conditional operator");
2023  rhsBlock = Builder.GetInsertBlock();
2024
2025  EmitBlock(contBlock);
2026
2027  llvm::PHINode *phi = Builder.CreatePHI(lhs.getAddress()->getType(), 2,
2028                                         "cond-lvalue");
2029  phi->addIncoming(lhs.getAddress(), lhsBlock);
2030  phi->addIncoming(rhs.getAddress(), rhsBlock);
2031  return MakeAddrLValue(phi, expr->getType());
2032}
2033
2034/// EmitCastLValue - Casts are never lvalues unless that cast is a dynamic_cast.
2035/// If the cast is a dynamic_cast, we can have the usual lvalue result,
2036/// otherwise if a cast is needed by the code generator in an lvalue context,
2037/// then it must mean that we need the address of an aggregate in order to
2038/// access one of its fields.  This can happen for all the reasons that casts
2039/// are permitted with aggregate result, including noop aggregate casts, and
2040/// cast from scalar to union.
2041LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) {
2042  switch (E->getCastKind()) {
2043  case CK_ToVoid:
2044    return EmitUnsupportedLValue(E, "unexpected cast lvalue");
2045
2046  case CK_Dependent:
2047    llvm_unreachable("dependent cast kind in IR gen!");
2048
2049  // These two casts are currently treated as no-ops, although they could
2050  // potentially be real operations depending on the target's ABI.
2051  case CK_NonAtomicToAtomic:
2052  case CK_AtomicToNonAtomic:
2053
2054  case CK_NoOp:
2055  case CK_LValueToRValue:
2056    if (!E->getSubExpr()->Classify(getContext()).isPRValue()
2057        || E->getType()->isRecordType())
2058      return EmitLValue(E->getSubExpr());
2059    // Fall through to synthesize a temporary.
2060
2061  case CK_BitCast:
2062  case CK_ArrayToPointerDecay:
2063  case CK_FunctionToPointerDecay:
2064  case CK_NullToMemberPointer:
2065  case CK_NullToPointer:
2066  case CK_IntegralToPointer:
2067  case CK_PointerToIntegral:
2068  case CK_PointerToBoolean:
2069  case CK_VectorSplat:
2070  case CK_IntegralCast:
2071  case CK_IntegralToBoolean:
2072  case CK_IntegralToFloating:
2073  case CK_FloatingToIntegral:
2074  case CK_FloatingToBoolean:
2075  case CK_FloatingCast:
2076  case CK_FloatingRealToComplex:
2077  case CK_FloatingComplexToReal:
2078  case CK_FloatingComplexToBoolean:
2079  case CK_FloatingComplexCast:
2080  case CK_FloatingComplexToIntegralComplex:
2081  case CK_IntegralRealToComplex:
2082  case CK_IntegralComplexToReal:
2083  case CK_IntegralComplexToBoolean:
2084  case CK_IntegralComplexCast:
2085  case CK_IntegralComplexToFloatingComplex:
2086  case CK_DerivedToBaseMemberPointer:
2087  case CK_BaseToDerivedMemberPointer:
2088  case CK_MemberPointerToBoolean:
2089  case CK_AnyPointerToBlockPointerCast:
2090  case CK_ARCProduceObject:
2091  case CK_ARCConsumeObject:
2092  case CK_ARCReclaimReturnedObject:
2093  case CK_ARCExtendBlockObject: {
2094    // These casts only produce lvalues when we're binding a reference to a
2095    // temporary realized from a (converted) pure rvalue. Emit the expression
2096    // as a value, copy it into a temporary, and return an lvalue referring to
2097    // that temporary.
2098    llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp");
2099    EmitAnyExprToMem(E, V, E->getType().getQualifiers(), false);
2100    return MakeAddrLValue(V, E->getType());
2101  }
2102
2103  case CK_Dynamic: {
2104    LValue LV = EmitLValue(E->getSubExpr());
2105    llvm::Value *V = LV.getAddress();
2106    const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E);
2107    return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType());
2108  }
2109
2110  case CK_ConstructorConversion:
2111  case CK_UserDefinedConversion:
2112  case CK_CPointerToObjCPointerCast:
2113  case CK_BlockPointerToObjCPointerCast:
2114    return EmitLValue(E->getSubExpr());
2115
2116  case CK_UncheckedDerivedToBase:
2117  case CK_DerivedToBase: {
2118    const RecordType *DerivedClassTy =
2119      E->getSubExpr()->getType()->getAs<RecordType>();
2120    CXXRecordDecl *DerivedClassDecl =
2121      cast<CXXRecordDecl>(DerivedClassTy->getDecl());
2122
2123    LValue LV = EmitLValue(E->getSubExpr());
2124    llvm::Value *This = LV.getAddress();
2125
2126    // Perform the derived-to-base conversion
2127    llvm::Value *Base =
2128      GetAddressOfBaseClass(This, DerivedClassDecl,
2129                            E->path_begin(), E->path_end(),
2130                            /*NullCheckValue=*/false);
2131
2132    return MakeAddrLValue(Base, E->getType());
2133  }
2134  case CK_ToUnion:
2135    return EmitAggExprToLValue(E);
2136  case CK_BaseToDerived: {
2137    const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>();
2138    CXXRecordDecl *DerivedClassDecl =
2139      cast<CXXRecordDecl>(DerivedClassTy->getDecl());
2140
2141    LValue LV = EmitLValue(E->getSubExpr());
2142
2143    // Perform the base-to-derived conversion
2144    llvm::Value *Derived =
2145      GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl,
2146                               E->path_begin(), E->path_end(),
2147                               /*NullCheckValue=*/false);
2148
2149    return MakeAddrLValue(Derived, E->getType());
2150  }
2151  case CK_LValueBitCast: {
2152    // This must be a reinterpret_cast (or c-style equivalent).
2153    const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E);
2154
2155    LValue LV = EmitLValue(E->getSubExpr());
2156    llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2157                                           ConvertType(CE->getTypeAsWritten()));
2158    return MakeAddrLValue(V, E->getType());
2159  }
2160  case CK_ObjCObjectLValueCast: {
2161    LValue LV = EmitLValue(E->getSubExpr());
2162    QualType ToType = getContext().getLValueReferenceType(E->getType());
2163    llvm::Value *V = Builder.CreateBitCast(LV.getAddress(),
2164                                           ConvertType(ToType));
2165    return MakeAddrLValue(V, E->getType());
2166  }
2167  }
2168
2169  llvm_unreachable("Unhandled lvalue cast kind?");
2170}
2171
2172LValue CodeGenFunction::EmitNullInitializationLValue(
2173                                              const CXXScalarValueInitExpr *E) {
2174  QualType Ty = E->getType();
2175  LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty);
2176  EmitNullInitialization(LV.getAddress(), Ty);
2177  return LV;
2178}
2179
2180LValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) {
2181  assert(OpaqueValueMappingData::shouldBindAsLValue(e));
2182  return getOpaqueLValueMapping(e);
2183}
2184
2185LValue CodeGenFunction::EmitMaterializeTemporaryExpr(
2186                                           const MaterializeTemporaryExpr *E) {
2187  RValue RV = EmitReferenceBindingToExpr(E, /*InitializedDecl=*/0);
2188  return MakeAddrLValue(RV.getScalarVal(), E->getType());
2189}
2190
2191
2192//===--------------------------------------------------------------------===//
2193//                             Expression Emission
2194//===--------------------------------------------------------------------===//
2195
2196RValue CodeGenFunction::EmitCallExpr(const CallExpr *E,
2197                                     ReturnValueSlot ReturnValue) {
2198  if (CGDebugInfo *DI = getDebugInfo())
2199    DI->EmitLocation(Builder, E->getLocStart());
2200
2201  // Builtins never have block type.
2202  if (E->getCallee()->getType()->isBlockPointerType())
2203    return EmitBlockCallExpr(E, ReturnValue);
2204
2205  if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E))
2206    return EmitCXXMemberCallExpr(CE, ReturnValue);
2207
2208  if (const CUDAKernelCallExpr *CE = dyn_cast<CUDAKernelCallExpr>(E))
2209    return EmitCUDAKernelCallExpr(CE, ReturnValue);
2210
2211  const Decl *TargetDecl = E->getCalleeDecl();
2212  if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(TargetDecl)) {
2213    if (unsigned builtinID = FD->getBuiltinID())
2214      return EmitBuiltinExpr(FD, builtinID, E);
2215  }
2216
2217  if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E))
2218    if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl))
2219      return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue);
2220
2221  if (const CXXPseudoDestructorExpr *PseudoDtor
2222          = dyn_cast<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) {
2223    QualType DestroyedType = PseudoDtor->getDestroyedType();
2224    if (getContext().getLangOptions().ObjCAutoRefCount &&
2225        DestroyedType->isObjCLifetimeType() &&
2226        (DestroyedType.getObjCLifetime() == Qualifiers::OCL_Strong ||
2227         DestroyedType.getObjCLifetime() == Qualifiers::OCL_Weak)) {
2228      // Automatic Reference Counting:
2229      //   If the pseudo-expression names a retainable object with weak or
2230      //   strong lifetime, the object shall be released.
2231      Expr *BaseExpr = PseudoDtor->getBase();
2232      llvm::Value *BaseValue = NULL;
2233      Qualifiers BaseQuals;
2234
2235      // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar.
2236      if (PseudoDtor->isArrow()) {
2237        BaseValue = EmitScalarExpr(BaseExpr);
2238        const PointerType *PTy = BaseExpr->getType()->getAs<PointerType>();
2239        BaseQuals = PTy->getPointeeType().getQualifiers();
2240      } else {
2241        LValue BaseLV = EmitLValue(BaseExpr);
2242        BaseValue = BaseLV.getAddress();
2243        QualType BaseTy = BaseExpr->getType();
2244        BaseQuals = BaseTy.getQualifiers();
2245      }
2246
2247      switch (PseudoDtor->getDestroyedType().getObjCLifetime()) {
2248      case Qualifiers::OCL_None:
2249      case Qualifiers::OCL_ExplicitNone:
2250      case Qualifiers::OCL_Autoreleasing:
2251        break;
2252
2253      case Qualifiers::OCL_Strong:
2254        EmitARCRelease(Builder.CreateLoad(BaseValue,
2255                          PseudoDtor->getDestroyedType().isVolatileQualified()),
2256                       /*precise*/ true);
2257        break;
2258
2259      case Qualifiers::OCL_Weak:
2260        EmitARCDestroyWeak(BaseValue);
2261        break;
2262      }
2263    } else {
2264      // C++ [expr.pseudo]p1:
2265      //   The result shall only be used as the operand for the function call
2266      //   operator (), and the result of such a call has type void. The only
2267      //   effect is the evaluation of the postfix-expression before the dot or
2268      //   arrow.
2269      EmitScalarExpr(E->getCallee());
2270    }
2271
2272    return RValue::get(0);
2273  }
2274
2275  llvm::Value *Callee = EmitScalarExpr(E->getCallee());
2276  return EmitCall(E->getCallee()->getType(), Callee, ReturnValue,
2277                  E->arg_begin(), E->arg_end(), TargetDecl);
2278}
2279
2280LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) {
2281  // Comma expressions just emit their LHS then their RHS as an l-value.
2282  if (E->getOpcode() == BO_Comma) {
2283    EmitIgnoredExpr(E->getLHS());
2284    EnsureInsertPoint();
2285    return EmitLValue(E->getRHS());
2286  }
2287
2288  if (E->getOpcode() == BO_PtrMemD ||
2289      E->getOpcode() == BO_PtrMemI)
2290    return EmitPointerToDataMemberBinaryExpr(E);
2291
2292  assert(E->getOpcode() == BO_Assign && "unexpected binary l-value");
2293
2294  // Note that in all of these cases, __block variables need the RHS
2295  // evaluated first just in case the variable gets moved by the RHS.
2296
2297  if (!hasAggregateLLVMType(E->getType())) {
2298    switch (E->getLHS()->getType().getObjCLifetime()) {
2299    case Qualifiers::OCL_Strong:
2300      return EmitARCStoreStrong(E, /*ignored*/ false).first;
2301
2302    case Qualifiers::OCL_Autoreleasing:
2303      return EmitARCStoreAutoreleasing(E).first;
2304
2305    // No reason to do any of these differently.
2306    case Qualifiers::OCL_None:
2307    case Qualifiers::OCL_ExplicitNone:
2308    case Qualifiers::OCL_Weak:
2309      break;
2310    }
2311
2312    RValue RV = EmitAnyExpr(E->getRHS());
2313    LValue LV = EmitLValue(E->getLHS());
2314    EmitStoreThroughLValue(RV, LV);
2315    return LV;
2316  }
2317
2318  if (E->getType()->isAnyComplexType())
2319    return EmitComplexAssignmentLValue(E);
2320
2321  return EmitAggExprToLValue(E);
2322}
2323
2324LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
2325  RValue RV = EmitCallExpr(E);
2326
2327  if (!RV.isScalar())
2328    return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
2329
2330  assert(E->getCallReturnType()->isReferenceType() &&
2331         "Can't have a scalar return unless the return type is a "
2332         "reference type!");
2333
2334  return MakeAddrLValue(RV.getScalarVal(), E->getType());
2335}
2336
2337LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
2338  // FIXME: This shouldn't require another copy.
2339  return EmitAggExprToLValue(E);
2340}
2341
2342LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
2343  assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor()
2344         && "binding l-value to type which needs a temporary");
2345  AggValueSlot Slot = CreateAggTemp(E->getType());
2346  EmitCXXConstructExpr(E, Slot);
2347  return MakeAddrLValue(Slot.getAddr(), E->getType());
2348}
2349
2350LValue
2351CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) {
2352  return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType());
2353}
2354
2355LValue
2356CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) {
2357  AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
2358  Slot.setExternallyDestructed();
2359  EmitAggExpr(E->getSubExpr(), Slot);
2360  EmitCXXTemporary(E->getTemporary(), E->getType(), Slot.getAddr());
2361  return MakeAddrLValue(Slot.getAddr(), E->getType());
2362}
2363
2364LValue
2365CodeGenFunction::EmitLambdaLValue(const LambdaExpr *E) {
2366  AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue");
2367  EmitLambdaExpr(E, Slot);
2368  return MakeAddrLValue(Slot.getAddr(), E->getType());
2369}
2370
2371LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) {
2372  RValue RV = EmitObjCMessageExpr(E);
2373
2374  if (!RV.isScalar())
2375    return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
2376
2377  assert(E->getMethodDecl()->getResultType()->isReferenceType() &&
2378         "Can't have a scalar return unless the return type is a "
2379         "reference type!");
2380
2381  return MakeAddrLValue(RV.getScalarVal(), E->getType());
2382}
2383
2384LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) {
2385  llvm::Value *V =
2386    CGM.getObjCRuntime().GetSelector(Builder, E->getSelector(), true);
2387  return MakeAddrLValue(V, E->getType());
2388}
2389
2390llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface,
2391                                             const ObjCIvarDecl *Ivar) {
2392  return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar);
2393}
2394
2395LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy,
2396                                          llvm::Value *BaseValue,
2397                                          const ObjCIvarDecl *Ivar,
2398                                          unsigned CVRQualifiers) {
2399  return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue,
2400                                                   Ivar, CVRQualifiers);
2401}
2402
2403LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) {
2404  // FIXME: A lot of the code below could be shared with EmitMemberExpr.
2405  llvm::Value *BaseValue = 0;
2406  const Expr *BaseExpr = E->getBase();
2407  Qualifiers BaseQuals;
2408  QualType ObjectTy;
2409  if (E->isArrow()) {
2410    BaseValue = EmitScalarExpr(BaseExpr);
2411    ObjectTy = BaseExpr->getType()->getPointeeType();
2412    BaseQuals = ObjectTy.getQualifiers();
2413  } else {
2414    LValue BaseLV = EmitLValue(BaseExpr);
2415    // FIXME: this isn't right for bitfields.
2416    BaseValue = BaseLV.getAddress();
2417    ObjectTy = BaseExpr->getType();
2418    BaseQuals = ObjectTy.getQualifiers();
2419  }
2420
2421  LValue LV =
2422    EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(),
2423                      BaseQuals.getCVRQualifiers());
2424  setObjCGCLValueClass(getContext(), E, LV);
2425  return LV;
2426}
2427
2428LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) {
2429  // Can only get l-value for message expression returning aggregate type
2430  RValue RV = EmitAnyExprToTemp(E);
2431  return MakeAddrLValue(RV.getAggregateAddr(), E->getType());
2432}
2433
2434RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee,
2435                                 ReturnValueSlot ReturnValue,
2436                                 CallExpr::const_arg_iterator ArgBeg,
2437                                 CallExpr::const_arg_iterator ArgEnd,
2438                                 const Decl *TargetDecl) {
2439  // Get the actual function type. The callee type will always be a pointer to
2440  // function type or a block pointer type.
2441  assert(CalleeType->isFunctionPointerType() &&
2442         "Call must have function pointer type!");
2443
2444  CalleeType = getContext().getCanonicalType(CalleeType);
2445
2446  const FunctionType *FnType
2447    = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType());
2448
2449  CallArgList Args;
2450  EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd);
2451
2452  const CGFunctionInfo &FnInfo = CGM.getTypes().getFunctionInfo(Args, FnType);
2453
2454  // C99 6.5.2.2p6:
2455  //   If the expression that denotes the called function has a type
2456  //   that does not include a prototype, [the default argument
2457  //   promotions are performed]. If the number of arguments does not
2458  //   equal the number of parameters, the behavior is undefined. If
2459  //   the function is defined with a type that includes a prototype,
2460  //   and either the prototype ends with an ellipsis (, ...) or the
2461  //   types of the arguments after promotion are not compatible with
2462  //   the types of the parameters, the behavior is undefined. If the
2463  //   function is defined with a type that does not include a
2464  //   prototype, and the types of the arguments after promotion are
2465  //   not compatible with those of the parameters after promotion,
2466  //   the behavior is undefined [except in some trivial cases].
2467  // That is, in the general case, we should assume that a call
2468  // through an unprototyped function type works like a *non-variadic*
2469  // call.  The way we make this work is to cast to the exact type
2470  // of the promoted arguments.
2471  if (isa<FunctionNoProtoType>(FnType) &&
2472      !getTargetHooks().isNoProtoCallVariadic(FnInfo)) {
2473    assert(cast<llvm::FunctionType>(Callee->getType()->getContainedType(0))
2474             ->isVarArg());
2475    llvm::Type *CalleeTy = getTypes().GetFunctionType(FnInfo, false);
2476    CalleeTy = CalleeTy->getPointerTo();
2477    Callee = Builder.CreateBitCast(Callee, CalleeTy, "callee.knr.cast");
2478  }
2479
2480  return EmitCall(FnInfo, Callee, ReturnValue, Args, TargetDecl);
2481}
2482
2483LValue CodeGenFunction::
2484EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) {
2485  llvm::Value *BaseV;
2486  if (E->getOpcode() == BO_PtrMemI)
2487    BaseV = EmitScalarExpr(E->getLHS());
2488  else
2489    BaseV = EmitLValue(E->getLHS()).getAddress();
2490
2491  llvm::Value *OffsetV = EmitScalarExpr(E->getRHS());
2492
2493  const MemberPointerType *MPT
2494    = E->getRHS()->getType()->getAs<MemberPointerType>();
2495
2496  llvm::Value *AddV =
2497    CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT);
2498
2499  return MakeAddrLValue(AddV, MPT->getPointeeType());
2500}
2501
2502static void
2503EmitAtomicOp(CodeGenFunction &CGF, AtomicExpr *E, llvm::Value *Dest,
2504             llvm::Value *Ptr, llvm::Value *Val1, llvm::Value *Val2,
2505             uint64_t Size, unsigned Align, llvm::AtomicOrdering Order) {
2506  if (E->isCmpXChg()) {
2507    // Note that cmpxchg only supports specifying one ordering and
2508    // doesn't support weak cmpxchg, at least at the moment.
2509    llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2510    LoadVal1->setAlignment(Align);
2511    llvm::LoadInst *LoadVal2 = CGF.Builder.CreateLoad(Val2);
2512    LoadVal2->setAlignment(Align);
2513    llvm::AtomicCmpXchgInst *CXI =
2514        CGF.Builder.CreateAtomicCmpXchg(Ptr, LoadVal1, LoadVal2, Order);
2515    CXI->setVolatile(E->isVolatile());
2516    llvm::StoreInst *StoreVal1 = CGF.Builder.CreateStore(CXI, Val1);
2517    StoreVal1->setAlignment(Align);
2518    llvm::Value *Cmp = CGF.Builder.CreateICmpEQ(CXI, LoadVal1);
2519    CGF.EmitStoreOfScalar(Cmp, CGF.MakeAddrLValue(Dest, E->getType()));
2520    return;
2521  }
2522
2523  if (E->getOp() == AtomicExpr::Load) {
2524    llvm::LoadInst *Load = CGF.Builder.CreateLoad(Ptr);
2525    Load->setAtomic(Order);
2526    Load->setAlignment(Size);
2527    Load->setVolatile(E->isVolatile());
2528    llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(Load, Dest);
2529    StoreDest->setAlignment(Align);
2530    return;
2531  }
2532
2533  if (E->getOp() == AtomicExpr::Store) {
2534    assert(!Dest && "Store does not return a value");
2535    llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2536    LoadVal1->setAlignment(Align);
2537    llvm::StoreInst *Store = CGF.Builder.CreateStore(LoadVal1, Ptr);
2538    Store->setAtomic(Order);
2539    Store->setAlignment(Size);
2540    Store->setVolatile(E->isVolatile());
2541    return;
2542  }
2543
2544  llvm::AtomicRMWInst::BinOp Op = llvm::AtomicRMWInst::Add;
2545  switch (E->getOp()) {
2546    case AtomicExpr::CmpXchgWeak:
2547    case AtomicExpr::CmpXchgStrong:
2548    case AtomicExpr::Store:
2549    case AtomicExpr::Init:
2550    case AtomicExpr::Load:  assert(0 && "Already handled!");
2551    case AtomicExpr::Add:   Op = llvm::AtomicRMWInst::Add;  break;
2552    case AtomicExpr::Sub:   Op = llvm::AtomicRMWInst::Sub;  break;
2553    case AtomicExpr::And:   Op = llvm::AtomicRMWInst::And;  break;
2554    case AtomicExpr::Or:    Op = llvm::AtomicRMWInst::Or;   break;
2555    case AtomicExpr::Xor:   Op = llvm::AtomicRMWInst::Xor;  break;
2556    case AtomicExpr::Xchg:  Op = llvm::AtomicRMWInst::Xchg; break;
2557  }
2558  llvm::LoadInst *LoadVal1 = CGF.Builder.CreateLoad(Val1);
2559  LoadVal1->setAlignment(Align);
2560  llvm::AtomicRMWInst *RMWI =
2561      CGF.Builder.CreateAtomicRMW(Op, Ptr, LoadVal1, Order);
2562  RMWI->setVolatile(E->isVolatile());
2563  llvm::StoreInst *StoreDest = CGF.Builder.CreateStore(RMWI, Dest);
2564  StoreDest->setAlignment(Align);
2565}
2566
2567// This function emits any expression (scalar, complex, or aggregate)
2568// into a temporary alloca.
2569static llvm::Value *
2570EmitValToTemp(CodeGenFunction &CGF, Expr *E) {
2571  llvm::Value *DeclPtr = CGF.CreateMemTemp(E->getType(), ".atomictmp");
2572  CGF.EmitAnyExprToMem(E, DeclPtr, E->getType().getQualifiers(),
2573                       /*Init*/ true);
2574  return DeclPtr;
2575}
2576
2577static RValue ConvertTempToRValue(CodeGenFunction &CGF, QualType Ty,
2578                                  llvm::Value *Dest) {
2579  if (Ty->isAnyComplexType())
2580    return RValue::getComplex(CGF.LoadComplexFromAddr(Dest, false));
2581  if (CGF.hasAggregateLLVMType(Ty))
2582    return RValue::getAggregate(Dest);
2583  return RValue::get(CGF.EmitLoadOfScalar(CGF.MakeAddrLValue(Dest, Ty)));
2584}
2585
2586RValue CodeGenFunction::EmitAtomicExpr(AtomicExpr *E, llvm::Value *Dest) {
2587  QualType AtomicTy = E->getPtr()->getType()->getPointeeType();
2588  QualType MemTy = AtomicTy->getAs<AtomicType>()->getValueType();
2589  CharUnits sizeChars = getContext().getTypeSizeInChars(AtomicTy);
2590  uint64_t Size = sizeChars.getQuantity();
2591  CharUnits alignChars = getContext().getTypeAlignInChars(AtomicTy);
2592  unsigned Align = alignChars.getQuantity();
2593  unsigned MaxInlineWidth =
2594      getContext().getTargetInfo().getMaxAtomicInlineWidth();
2595  bool UseLibcall = (Size != Align || Size > MaxInlineWidth);
2596
2597
2598
2599  llvm::Value *Ptr, *Order, *OrderFail = 0, *Val1 = 0, *Val2 = 0;
2600  Ptr = EmitScalarExpr(E->getPtr());
2601
2602  if (E->getOp() == AtomicExpr::Init) {
2603    assert(!Dest && "Init does not return a value");
2604    Val1 = EmitScalarExpr(E->getVal1());
2605    llvm::StoreInst *Store = Builder.CreateStore(Val1, Ptr);
2606    Store->setAlignment(Size);
2607    Store->setVolatile(E->isVolatile());
2608    return RValue::get(0);
2609  }
2610
2611  Order = EmitScalarExpr(E->getOrder());
2612  if (E->isCmpXChg()) {
2613    Val1 = EmitScalarExpr(E->getVal1());
2614    Val2 = EmitValToTemp(*this, E->getVal2());
2615    OrderFail = EmitScalarExpr(E->getOrderFail());
2616    (void)OrderFail; // OrderFail is unused at the moment
2617  } else if ((E->getOp() == AtomicExpr::Add || E->getOp() == AtomicExpr::Sub) &&
2618             MemTy->isPointerType()) {
2619    // For pointers, we're required to do a bit of math: adding 1 to an int*
2620    // is not the same as adding 1 to a uintptr_t.
2621    QualType Val1Ty = E->getVal1()->getType();
2622    llvm::Value *Val1Scalar = EmitScalarExpr(E->getVal1());
2623    CharUnits PointeeIncAmt =
2624        getContext().getTypeSizeInChars(MemTy->getPointeeType());
2625    Val1Scalar = Builder.CreateMul(Val1Scalar, CGM.getSize(PointeeIncAmt));
2626    Val1 = CreateMemTemp(Val1Ty, ".atomictmp");
2627    EmitStoreOfScalar(Val1Scalar, MakeAddrLValue(Val1, Val1Ty));
2628  } else if (E->getOp() != AtomicExpr::Load) {
2629    Val1 = EmitValToTemp(*this, E->getVal1());
2630  }
2631
2632  if (E->getOp() != AtomicExpr::Store && !Dest)
2633    Dest = CreateMemTemp(E->getType(), ".atomicdst");
2634
2635  if (UseLibcall) {
2636    // FIXME: Finalize what the libcalls are actually supposed to look like.
2637    // See also http://gcc.gnu.org/wiki/Atomic/GCCMM/LIbrary .
2638    return EmitUnsupportedRValue(E, "atomic library call");
2639  }
2640#if 0
2641  if (UseLibcall) {
2642    const char* LibCallName;
2643    switch (E->getOp()) {
2644    case AtomicExpr::CmpXchgWeak:
2645      LibCallName = "__atomic_compare_exchange_generic"; break;
2646    case AtomicExpr::CmpXchgStrong:
2647      LibCallName = "__atomic_compare_exchange_generic"; break;
2648    case AtomicExpr::Add:   LibCallName = "__atomic_fetch_add_generic"; break;
2649    case AtomicExpr::Sub:   LibCallName = "__atomic_fetch_sub_generic"; break;
2650    case AtomicExpr::And:   LibCallName = "__atomic_fetch_and_generic"; break;
2651    case AtomicExpr::Or:    LibCallName = "__atomic_fetch_or_generic"; break;
2652    case AtomicExpr::Xor:   LibCallName = "__atomic_fetch_xor_generic"; break;
2653    case AtomicExpr::Xchg:  LibCallName = "__atomic_exchange_generic"; break;
2654    case AtomicExpr::Store: LibCallName = "__atomic_store_generic"; break;
2655    case AtomicExpr::Load:  LibCallName = "__atomic_load_generic"; break;
2656    }
2657    llvm::SmallVector<QualType, 4> Params;
2658    CallArgList Args;
2659    QualType RetTy = getContext().VoidTy;
2660    if (E->getOp() != AtomicExpr::Store && !E->isCmpXChg())
2661      Args.add(RValue::get(EmitCastToVoidPtr(Dest)),
2662               getContext().VoidPtrTy);
2663    Args.add(RValue::get(EmitCastToVoidPtr(Ptr)),
2664             getContext().VoidPtrTy);
2665    if (E->getOp() != AtomicExpr::Load)
2666      Args.add(RValue::get(EmitCastToVoidPtr(Val1)),
2667               getContext().VoidPtrTy);
2668    if (E->isCmpXChg()) {
2669      Args.add(RValue::get(EmitCastToVoidPtr(Val2)),
2670               getContext().VoidPtrTy);
2671      RetTy = getContext().IntTy;
2672    }
2673    Args.add(RValue::get(llvm::ConstantInt::get(SizeTy, Size)),
2674             getContext().getSizeType());
2675    const CGFunctionInfo &FuncInfo =
2676        CGM.getTypes().getFunctionInfo(RetTy, Args, FunctionType::ExtInfo());
2677    llvm::FunctionType *FTy = CGM.getTypes().GetFunctionType(FuncInfo, false);
2678    llvm::Constant *Func = CGM.CreateRuntimeFunction(FTy, LibCallName);
2679    RValue Res = EmitCall(FuncInfo, Func, ReturnValueSlot(), Args);
2680    if (E->isCmpXChg())
2681      return Res;
2682    if (E->getOp() == AtomicExpr::Store)
2683      return RValue::get(0);
2684    return ConvertTempToRValue(*this, E->getType(), Dest);
2685  }
2686#endif
2687  llvm::Type *IPtrTy =
2688      llvm::IntegerType::get(getLLVMContext(), Size * 8)->getPointerTo();
2689  llvm::Value *OrigDest = Dest;
2690  Ptr = Builder.CreateBitCast(Ptr, IPtrTy);
2691  if (Val1) Val1 = Builder.CreateBitCast(Val1, IPtrTy);
2692  if (Val2) Val2 = Builder.CreateBitCast(Val2, IPtrTy);
2693  if (Dest && !E->isCmpXChg()) Dest = Builder.CreateBitCast(Dest, IPtrTy);
2694
2695  if (isa<llvm::ConstantInt>(Order)) {
2696    int ord = cast<llvm::ConstantInt>(Order)->getZExtValue();
2697    switch (ord) {
2698    case 0:  // memory_order_relaxed
2699      EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
2700                   llvm::Monotonic);
2701      break;
2702    case 1:  // memory_order_consume
2703    case 2:  // memory_order_acquire
2704      EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
2705                   llvm::Acquire);
2706      break;
2707    case 3:  // memory_order_release
2708      EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
2709                   llvm::Release);
2710      break;
2711    case 4:  // memory_order_acq_rel
2712      EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
2713                   llvm::AcquireRelease);
2714      break;
2715    case 5:  // memory_order_seq_cst
2716      EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
2717                   llvm::SequentiallyConsistent);
2718      break;
2719    default: // invalid order
2720      // We should not ever get here normally, but it's hard to
2721      // enforce that in general.
2722      break;
2723    }
2724    if (E->getOp() == AtomicExpr::Store || E->getOp() == AtomicExpr::Init)
2725      return RValue::get(0);
2726    return ConvertTempToRValue(*this, E->getType(), OrigDest);
2727  }
2728
2729  // Long case, when Order isn't obviously constant.
2730
2731  // Create all the relevant BB's
2732  llvm::BasicBlock *MonotonicBB = 0, *AcquireBB = 0, *ReleaseBB = 0,
2733                   *AcqRelBB = 0, *SeqCstBB = 0;
2734  MonotonicBB = createBasicBlock("monotonic", CurFn);
2735  if (E->getOp() != AtomicExpr::Store)
2736    AcquireBB = createBasicBlock("acquire", CurFn);
2737  if (E->getOp() != AtomicExpr::Load)
2738    ReleaseBB = createBasicBlock("release", CurFn);
2739  if (E->getOp() != AtomicExpr::Load && E->getOp() != AtomicExpr::Store)
2740    AcqRelBB = createBasicBlock("acqrel", CurFn);
2741  SeqCstBB = createBasicBlock("seqcst", CurFn);
2742  llvm::BasicBlock *ContBB = createBasicBlock("atomic.continue", CurFn);
2743
2744  // Create the switch for the split
2745  // MonotonicBB is arbitrarily chosen as the default case; in practice, this
2746  // doesn't matter unless someone is crazy enough to use something that
2747  // doesn't fold to a constant for the ordering.
2748  Order = Builder.CreateIntCast(Order, Builder.getInt32Ty(), false);
2749  llvm::SwitchInst *SI = Builder.CreateSwitch(Order, MonotonicBB);
2750
2751  // Emit all the different atomics
2752  Builder.SetInsertPoint(MonotonicBB);
2753  EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
2754               llvm::Monotonic);
2755  Builder.CreateBr(ContBB);
2756  if (E->getOp() != AtomicExpr::Store) {
2757    Builder.SetInsertPoint(AcquireBB);
2758    EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
2759                 llvm::Acquire);
2760    Builder.CreateBr(ContBB);
2761    SI->addCase(Builder.getInt32(1), AcquireBB);
2762    SI->addCase(Builder.getInt32(2), AcquireBB);
2763  }
2764  if (E->getOp() != AtomicExpr::Load) {
2765    Builder.SetInsertPoint(ReleaseBB);
2766    EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
2767                 llvm::Release);
2768    Builder.CreateBr(ContBB);
2769    SI->addCase(Builder.getInt32(3), ReleaseBB);
2770  }
2771  if (E->getOp() != AtomicExpr::Load && E->getOp() != AtomicExpr::Store) {
2772    Builder.SetInsertPoint(AcqRelBB);
2773    EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
2774                 llvm::AcquireRelease);
2775    Builder.CreateBr(ContBB);
2776    SI->addCase(Builder.getInt32(4), AcqRelBB);
2777  }
2778  Builder.SetInsertPoint(SeqCstBB);
2779  EmitAtomicOp(*this, E, Dest, Ptr, Val1, Val2, Size, Align,
2780               llvm::SequentiallyConsistent);
2781  Builder.CreateBr(ContBB);
2782  SI->addCase(Builder.getInt32(5), SeqCstBB);
2783
2784  // Cleanup and return
2785  Builder.SetInsertPoint(ContBB);
2786  if (E->getOp() == AtomicExpr::Store)
2787    return RValue::get(0);
2788  return ConvertTempToRValue(*this, E->getType(), OrigDest);
2789}
2790
2791void CodeGenFunction::SetFPAccuracy(llvm::Value *Val, unsigned AccuracyN,
2792                                    unsigned AccuracyD) {
2793  assert(Val->getType()->isFPOrFPVectorTy());
2794  if (!AccuracyN || !isa<llvm::Instruction>(Val))
2795    return;
2796
2797  llvm::Value *Vals[2];
2798  Vals[0] = llvm::ConstantInt::get(Int32Ty, AccuracyN);
2799  Vals[1] = llvm::ConstantInt::get(Int32Ty, AccuracyD);
2800  llvm::MDNode *Node = llvm::MDNode::get(getLLVMContext(), Vals);
2801
2802  cast<llvm::Instruction>(Val)->setMetadata(llvm::LLVMContext::MD_fpaccuracy,
2803                                            Node);
2804}
2805
2806namespace {
2807  struct LValueOrRValue {
2808    LValue LV;
2809    RValue RV;
2810  };
2811}
2812
2813static LValueOrRValue emitPseudoObjectExpr(CodeGenFunction &CGF,
2814                                           const PseudoObjectExpr *E,
2815                                           bool forLValue,
2816                                           AggValueSlot slot) {
2817  llvm::SmallVector<CodeGenFunction::OpaqueValueMappingData, 4> opaques;
2818
2819  // Find the result expression, if any.
2820  const Expr *resultExpr = E->getResultExpr();
2821  LValueOrRValue result;
2822
2823  for (PseudoObjectExpr::const_semantics_iterator
2824         i = E->semantics_begin(), e = E->semantics_end(); i != e; ++i) {
2825    const Expr *semantic = *i;
2826
2827    // If this semantic expression is an opaque value, bind it
2828    // to the result of its source expression.
2829    if (const OpaqueValueExpr *ov = dyn_cast<OpaqueValueExpr>(semantic)) {
2830
2831      // If this is the result expression, we may need to evaluate
2832      // directly into the slot.
2833      typedef CodeGenFunction::OpaqueValueMappingData OVMA;
2834      OVMA opaqueData;
2835      if (ov == resultExpr && ov->isRValue() && !forLValue &&
2836          CodeGenFunction::hasAggregateLLVMType(ov->getType()) &&
2837          !ov->getType()->isAnyComplexType()) {
2838        CGF.EmitAggExpr(ov->getSourceExpr(), slot);
2839
2840        LValue LV = CGF.MakeAddrLValue(slot.getAddr(), ov->getType());
2841        opaqueData = OVMA::bind(CGF, ov, LV);
2842        result.RV = slot.asRValue();
2843
2844      // Otherwise, emit as normal.
2845      } else {
2846        opaqueData = OVMA::bind(CGF, ov, ov->getSourceExpr());
2847
2848        // If this is the result, also evaluate the result now.
2849        if (ov == resultExpr) {
2850          if (forLValue)
2851            result.LV = CGF.EmitLValue(ov);
2852          else
2853            result.RV = CGF.EmitAnyExpr(ov, slot);
2854        }
2855      }
2856
2857      opaques.push_back(opaqueData);
2858
2859    // Otherwise, if the expression is the result, evaluate it
2860    // and remember the result.
2861    } else if (semantic == resultExpr) {
2862      if (forLValue)
2863        result.LV = CGF.EmitLValue(semantic);
2864      else
2865        result.RV = CGF.EmitAnyExpr(semantic, slot);
2866
2867    // Otherwise, evaluate the expression in an ignored context.
2868    } else {
2869      CGF.EmitIgnoredExpr(semantic);
2870    }
2871  }
2872
2873  // Unbind all the opaques now.
2874  for (unsigned i = 0, e = opaques.size(); i != e; ++i)
2875    opaques[i].unbind(CGF);
2876
2877  return result;
2878}
2879
2880RValue CodeGenFunction::EmitPseudoObjectRValue(const PseudoObjectExpr *E,
2881                                               AggValueSlot slot) {
2882  return emitPseudoObjectExpr(*this, E, false, slot).RV;
2883}
2884
2885LValue CodeGenFunction::EmitPseudoObjectLValue(const PseudoObjectExpr *E) {
2886  return emitPseudoObjectExpr(*this, E, true, AggValueSlot::ignored()).LV;
2887}
2888