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