CGExpr.cpp revision bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315
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 "clang/AST/ASTContext.h" 22#include "clang/AST/DeclObjC.h" 23#include "llvm/Intrinsics.h" 24#include "clang/Frontend/CodeGenOptions.h" 25#include "llvm/Target/TargetData.h" 26using namespace clang; 27using namespace CodeGen; 28 29//===--------------------------------------------------------------------===// 30// Miscellaneous Helper Methods 31//===--------------------------------------------------------------------===// 32 33llvm::Value *CodeGenFunction::EmitCastToVoidPtr(llvm::Value *value) { 34 unsigned addressSpace = 35 cast<llvm::PointerType>(value->getType())->getAddressSpace(); 36 37 const llvm::PointerType *destType = Int8PtrTy; 38 if (addressSpace) 39 destType = llvm::Type::getInt8PtrTy(getLLVMContext(), addressSpace); 40 41 if (value->getType() == destType) return value; 42 return Builder.CreateBitCast(value, destType); 43} 44 45/// CreateTempAlloca - This creates a alloca and inserts it into the entry 46/// block. 47llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(const llvm::Type *Ty, 48 const llvm::Twine &Name) { 49 if (!Builder.isNamePreserving()) 50 return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt); 51 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt); 52} 53 54void CodeGenFunction::InitTempAlloca(llvm::AllocaInst *Var, 55 llvm::Value *Init) { 56 llvm::StoreInst *Store = new llvm::StoreInst(Init, Var); 57 llvm::BasicBlock *Block = AllocaInsertPt->getParent(); 58 Block->getInstList().insertAfter(&*AllocaInsertPt, Store); 59} 60 61llvm::AllocaInst *CodeGenFunction::CreateIRTemp(QualType Ty, 62 const llvm::Twine &Name) { 63 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertType(Ty), Name); 64 // FIXME: Should we prefer the preferred type alignment here? 65 CharUnits Align = getContext().getTypeAlignInChars(Ty); 66 Alloc->setAlignment(Align.getQuantity()); 67 return Alloc; 68} 69 70llvm::AllocaInst *CodeGenFunction::CreateMemTemp(QualType Ty, 71 const llvm::Twine &Name) { 72 llvm::AllocaInst *Alloc = CreateTempAlloca(ConvertTypeForMem(Ty), Name); 73 // FIXME: Should we prefer the preferred type alignment here? 74 CharUnits Align = getContext().getTypeAlignInChars(Ty); 75 Alloc->setAlignment(Align.getQuantity()); 76 return Alloc; 77} 78 79/// EvaluateExprAsBool - Perform the usual unary conversions on the specified 80/// expression and compare the result against zero, returning an Int1Ty value. 81llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) { 82 if (const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>()) { 83 llvm::Value *MemPtr = EmitScalarExpr(E); 84 return CGM.getCXXABI().EmitMemberPointerIsNotNull(*this, MemPtr, MPT); 85 } 86 87 QualType BoolTy = getContext().BoolTy; 88 if (!E->getType()->isAnyComplexType()) 89 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy); 90 91 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy); 92} 93 94/// EmitIgnoredExpr - Emit code to compute the specified expression, 95/// ignoring the result. 96void CodeGenFunction::EmitIgnoredExpr(const Expr *E) { 97 if (E->isRValue()) 98 return (void) EmitAnyExpr(E, AggValueSlot::ignored(), true); 99 100 // Just emit it as an l-value and drop the result. 101 EmitLValue(E); 102} 103 104/// EmitAnyExpr - Emit code to compute the specified expression which 105/// can have any type. The result is returned as an RValue struct. 106/// If this is an aggregate expression, AggSlot indicates where the 107/// result should be returned. 108RValue CodeGenFunction::EmitAnyExpr(const Expr *E, AggValueSlot AggSlot, 109 bool IgnoreResult) { 110 if (!hasAggregateLLVMType(E->getType())) 111 return RValue::get(EmitScalarExpr(E, IgnoreResult)); 112 else if (E->getType()->isAnyComplexType()) 113 return RValue::getComplex(EmitComplexExpr(E, IgnoreResult, IgnoreResult)); 114 115 EmitAggExpr(E, AggSlot, IgnoreResult); 116 return AggSlot.asRValue(); 117} 118 119/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will 120/// always be accessible even if no aggregate location is provided. 121RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E) { 122 AggValueSlot AggSlot = AggValueSlot::ignored(); 123 124 if (hasAggregateLLVMType(E->getType()) && 125 !E->getType()->isAnyComplexType()) 126 AggSlot = CreateAggTemp(E->getType(), "agg.tmp"); 127 return EmitAnyExpr(E, AggSlot); 128} 129 130/// EmitAnyExprToMem - Evaluate an expression into a given memory 131/// location. 132void CodeGenFunction::EmitAnyExprToMem(const Expr *E, 133 llvm::Value *Location, 134 bool IsLocationVolatile, 135 bool IsInit) { 136 if (E->getType()->isComplexType()) 137 EmitComplexExprIntoAddr(E, Location, IsLocationVolatile); 138 else if (hasAggregateLLVMType(E->getType())) 139 EmitAggExpr(E, AggValueSlot::forAddr(Location, IsLocationVolatile, IsInit)); 140 else { 141 RValue RV = RValue::get(EmitScalarExpr(E, /*Ignore*/ false)); 142 LValue LV = MakeAddrLValue(Location, E->getType()); 143 EmitStoreThroughLValue(RV, LV, E->getType()); 144 } 145} 146 147namespace { 148/// \brief An adjustment to be made to the temporary created when emitting a 149/// reference binding, which accesses a particular subobject of that temporary. 150 struct SubobjectAdjustment { 151 enum { DerivedToBaseAdjustment, FieldAdjustment } Kind; 152 153 union { 154 struct { 155 const CastExpr *BasePath; 156 const CXXRecordDecl *DerivedClass; 157 } DerivedToBase; 158 159 FieldDecl *Field; 160 }; 161 162 SubobjectAdjustment(const CastExpr *BasePath, 163 const CXXRecordDecl *DerivedClass) 164 : Kind(DerivedToBaseAdjustment) { 165 DerivedToBase.BasePath = BasePath; 166 DerivedToBase.DerivedClass = DerivedClass; 167 } 168 169 SubobjectAdjustment(FieldDecl *Field) 170 : Kind(FieldAdjustment) { 171 this->Field = Field; 172 } 173 }; 174} 175 176static llvm::Value * 177CreateReferenceTemporary(CodeGenFunction& CGF, QualType Type, 178 const NamedDecl *InitializedDecl) { 179 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) { 180 if (VD->hasGlobalStorage()) { 181 llvm::SmallString<256> Name; 182 llvm::raw_svector_ostream Out(Name); 183 CGF.CGM.getCXXABI().getMangleContext().mangleReferenceTemporary(VD, Out); 184 Out.flush(); 185 186 const llvm::Type *RefTempTy = CGF.ConvertTypeForMem(Type); 187 188 // Create the reference temporary. 189 llvm::GlobalValue *RefTemp = 190 new llvm::GlobalVariable(CGF.CGM.getModule(), 191 RefTempTy, /*isConstant=*/false, 192 llvm::GlobalValue::InternalLinkage, 193 llvm::Constant::getNullValue(RefTempTy), 194 Name.str()); 195 return RefTemp; 196 } 197 } 198 199 return CGF.CreateMemTemp(Type, "ref.tmp"); 200} 201 202static llvm::Value * 203EmitExprForReferenceBinding(CodeGenFunction &CGF, const Expr *E, 204 llvm::Value *&ReferenceTemporary, 205 const CXXDestructorDecl *&ReferenceTemporaryDtor, 206 const NamedDecl *InitializedDecl) { 207 if (const CXXDefaultArgExpr *DAE = dyn_cast<CXXDefaultArgExpr>(E)) 208 E = DAE->getExpr(); 209 210 if (const ExprWithCleanups *TE = dyn_cast<ExprWithCleanups>(E)) { 211 CodeGenFunction::RunCleanupsScope Scope(CGF); 212 213 return EmitExprForReferenceBinding(CGF, TE->getSubExpr(), 214 ReferenceTemporary, 215 ReferenceTemporaryDtor, 216 InitializedDecl); 217 } 218 219 RValue RV; 220 if (E->isGLValue()) { 221 // Emit the expression as an lvalue. 222 LValue LV = CGF.EmitLValue(E); 223 if (LV.isSimple()) 224 return LV.getAddress(); 225 226 // We have to load the lvalue. 227 RV = CGF.EmitLoadOfLValue(LV, E->getType()); 228 } else { 229 QualType ResultTy = E->getType(); 230 231 llvm::SmallVector<SubobjectAdjustment, 2> Adjustments; 232 while (true) { 233 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) { 234 E = PE->getSubExpr(); 235 continue; 236 } 237 238 if (const CastExpr *CE = dyn_cast<CastExpr>(E)) { 239 if ((CE->getCastKind() == CK_DerivedToBase || 240 CE->getCastKind() == CK_UncheckedDerivedToBase) && 241 E->getType()->isRecordType()) { 242 E = CE->getSubExpr(); 243 CXXRecordDecl *Derived 244 = cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl()); 245 Adjustments.push_back(SubobjectAdjustment(CE, Derived)); 246 continue; 247 } 248 249 if (CE->getCastKind() == CK_NoOp) { 250 E = CE->getSubExpr(); 251 continue; 252 } 253 } else if (const MemberExpr *ME = dyn_cast<MemberExpr>(E)) { 254 if (!ME->isArrow() && ME->getBase()->isRValue()) { 255 assert(ME->getBase()->getType()->isRecordType()); 256 if (FieldDecl *Field = dyn_cast<FieldDecl>(ME->getMemberDecl())) { 257 E = ME->getBase(); 258 Adjustments.push_back(SubobjectAdjustment(Field)); 259 continue; 260 } 261 } 262 } 263 264 if (const OpaqueValueExpr *opaque = dyn_cast<OpaqueValueExpr>(E)) 265 if (opaque->getType()->isRecordType()) 266 return CGF.EmitOpaqueValueLValue(opaque).getAddress(); 267 268 // Nothing changed. 269 break; 270 } 271 272 // Create a reference temporary if necessary. 273 AggValueSlot AggSlot = AggValueSlot::ignored(); 274 if (CGF.hasAggregateLLVMType(E->getType()) && 275 !E->getType()->isAnyComplexType()) { 276 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(), 277 InitializedDecl); 278 AggSlot = AggValueSlot::forAddr(ReferenceTemporary, false, 279 InitializedDecl != 0); 280 } 281 282 RV = CGF.EmitAnyExpr(E, AggSlot); 283 284 if (InitializedDecl) { 285 // Get the destructor for the reference temporary. 286 if (const RecordType *RT = E->getType()->getAs<RecordType>()) { 287 CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(RT->getDecl()); 288 if (!ClassDecl->hasTrivialDestructor()) 289 ReferenceTemporaryDtor = ClassDecl->getDestructor(); 290 } 291 } 292 293 // Check if need to perform derived-to-base casts and/or field accesses, to 294 // get from the temporary object we created (and, potentially, for which we 295 // extended the lifetime) to the subobject we're binding the reference to. 296 if (!Adjustments.empty()) { 297 llvm::Value *Object = RV.getAggregateAddr(); 298 for (unsigned I = Adjustments.size(); I != 0; --I) { 299 SubobjectAdjustment &Adjustment = Adjustments[I-1]; 300 switch (Adjustment.Kind) { 301 case SubobjectAdjustment::DerivedToBaseAdjustment: 302 Object = 303 CGF.GetAddressOfBaseClass(Object, 304 Adjustment.DerivedToBase.DerivedClass, 305 Adjustment.DerivedToBase.BasePath->path_begin(), 306 Adjustment.DerivedToBase.BasePath->path_end(), 307 /*NullCheckValue=*/false); 308 break; 309 310 case SubobjectAdjustment::FieldAdjustment: { 311 LValue LV = 312 CGF.EmitLValueForField(Object, Adjustment.Field, 0); 313 if (LV.isSimple()) { 314 Object = LV.getAddress(); 315 break; 316 } 317 318 // For non-simple lvalues, we actually have to create a copy of 319 // the object we're binding to. 320 QualType T = Adjustment.Field->getType().getNonReferenceType() 321 .getUnqualifiedType(); 322 Object = CreateReferenceTemporary(CGF, T, InitializedDecl); 323 LValue TempLV = CGF.MakeAddrLValue(Object, 324 Adjustment.Field->getType()); 325 CGF.EmitStoreThroughLValue(CGF.EmitLoadOfLValue(LV, T), TempLV, T); 326 break; 327 } 328 329 } 330 } 331 332 return Object; 333 } 334 } 335 336 if (RV.isAggregate()) 337 return RV.getAggregateAddr(); 338 339 // Create a temporary variable that we can bind the reference to. 340 ReferenceTemporary = CreateReferenceTemporary(CGF, E->getType(), 341 InitializedDecl); 342 343 344 unsigned Alignment = 345 CGF.getContext().getTypeAlignInChars(E->getType()).getQuantity(); 346 if (RV.isScalar()) 347 CGF.EmitStoreOfScalar(RV.getScalarVal(), ReferenceTemporary, 348 /*Volatile=*/false, Alignment, E->getType()); 349 else 350 CGF.StoreComplexToAddr(RV.getComplexVal(), ReferenceTemporary, 351 /*Volatile=*/false); 352 return ReferenceTemporary; 353} 354 355RValue 356CodeGenFunction::EmitReferenceBindingToExpr(const Expr *E, 357 const NamedDecl *InitializedDecl) { 358 llvm::Value *ReferenceTemporary = 0; 359 const CXXDestructorDecl *ReferenceTemporaryDtor = 0; 360 llvm::Value *Value = EmitExprForReferenceBinding(*this, E, ReferenceTemporary, 361 ReferenceTemporaryDtor, 362 InitializedDecl); 363 if (!ReferenceTemporaryDtor) 364 return RValue::get(Value); 365 366 // Make sure to call the destructor for the reference temporary. 367 if (const VarDecl *VD = dyn_cast_or_null<VarDecl>(InitializedDecl)) { 368 if (VD->hasGlobalStorage()) { 369 llvm::Constant *DtorFn = 370 CGM.GetAddrOfCXXDestructor(ReferenceTemporaryDtor, Dtor_Complete); 371 EmitCXXGlobalDtorRegistration(DtorFn, 372 cast<llvm::Constant>(ReferenceTemporary)); 373 374 return RValue::get(Value); 375 } 376 } 377 378 PushDestructorCleanup(ReferenceTemporaryDtor, ReferenceTemporary); 379 380 return RValue::get(Value); 381} 382 383 384/// getAccessedFieldNo - Given an encoded value and a result number, return the 385/// input field number being accessed. 386unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx, 387 const llvm::Constant *Elts) { 388 if (isa<llvm::ConstantAggregateZero>(Elts)) 389 return 0; 390 391 return cast<llvm::ConstantInt>(Elts->getOperand(Idx))->getZExtValue(); 392} 393 394void CodeGenFunction::EmitCheck(llvm::Value *Address, unsigned Size) { 395 if (!CatchUndefined) 396 return; 397 398 // This needs to be to the standard address space. 399 Address = Builder.CreateBitCast(Address, Int8PtrTy); 400 401 const llvm::Type *IntPtrT = IntPtrTy; 402 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::objectsize, &IntPtrT, 1); 403 404 // In time, people may want to control this and use a 1 here. 405 llvm::Value *Arg = Builder.getFalse(); 406 llvm::Value *C = Builder.CreateCall2(F, Address, Arg); 407 llvm::BasicBlock *Cont = createBasicBlock(); 408 llvm::BasicBlock *Check = createBasicBlock(); 409 llvm::Value *NegativeOne = llvm::ConstantInt::get(IntPtrTy, -1ULL); 410 Builder.CreateCondBr(Builder.CreateICmpEQ(C, NegativeOne), Cont, Check); 411 412 EmitBlock(Check); 413 Builder.CreateCondBr(Builder.CreateICmpUGE(C, 414 llvm::ConstantInt::get(IntPtrTy, Size)), 415 Cont, getTrapBB()); 416 EmitBlock(Cont); 417} 418 419 420CodeGenFunction::ComplexPairTy CodeGenFunction:: 421EmitComplexPrePostIncDec(const UnaryOperator *E, LValue LV, 422 bool isInc, bool isPre) { 423 ComplexPairTy InVal = LoadComplexFromAddr(LV.getAddress(), 424 LV.isVolatileQualified()); 425 426 llvm::Value *NextVal; 427 if (isa<llvm::IntegerType>(InVal.first->getType())) { 428 uint64_t AmountVal = isInc ? 1 : -1; 429 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true); 430 431 // Add the inc/dec to the real part. 432 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 433 } else { 434 QualType ElemTy = E->getType()->getAs<ComplexType>()->getElementType(); 435 llvm::APFloat FVal(getContext().getFloatTypeSemantics(ElemTy), 1); 436 if (!isInc) 437 FVal.changeSign(); 438 NextVal = llvm::ConstantFP::get(getLLVMContext(), FVal); 439 440 // Add the inc/dec to the real part. 441 NextVal = Builder.CreateFAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 442 } 443 444 ComplexPairTy IncVal(NextVal, InVal.second); 445 446 // Store the updated result through the lvalue. 447 StoreComplexToAddr(IncVal, LV.getAddress(), LV.isVolatileQualified()); 448 449 // If this is a postinc, return the value read from memory, otherwise use the 450 // updated value. 451 return isPre ? IncVal : InVal; 452} 453 454 455//===----------------------------------------------------------------------===// 456// LValue Expression Emission 457//===----------------------------------------------------------------------===// 458 459RValue CodeGenFunction::GetUndefRValue(QualType Ty) { 460 if (Ty->isVoidType()) 461 return RValue::get(0); 462 463 if (const ComplexType *CTy = Ty->getAs<ComplexType>()) { 464 const llvm::Type *EltTy = ConvertType(CTy->getElementType()); 465 llvm::Value *U = llvm::UndefValue::get(EltTy); 466 return RValue::getComplex(std::make_pair(U, U)); 467 } 468 469 // If this is a use of an undefined aggregate type, the aggregate must have an 470 // identifiable address. Just because the contents of the value are undefined 471 // doesn't mean that the address can't be taken and compared. 472 if (hasAggregateLLVMType(Ty)) { 473 llvm::Value *DestPtr = CreateMemTemp(Ty, "undef.agg.tmp"); 474 return RValue::getAggregate(DestPtr); 475 } 476 477 return RValue::get(llvm::UndefValue::get(ConvertType(Ty))); 478} 479 480RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E, 481 const char *Name) { 482 ErrorUnsupported(E, Name); 483 return GetUndefRValue(E->getType()); 484} 485 486LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E, 487 const char *Name) { 488 ErrorUnsupported(E, Name); 489 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 490 return MakeAddrLValue(llvm::UndefValue::get(Ty), E->getType()); 491} 492 493LValue CodeGenFunction::EmitCheckedLValue(const Expr *E) { 494 LValue LV = EmitLValue(E); 495 if (!isa<DeclRefExpr>(E) && !LV.isBitField() && LV.isSimple()) 496 EmitCheck(LV.getAddress(), 497 getContext().getTypeSizeInChars(E->getType()).getQuantity()); 498 return LV; 499} 500 501/// EmitLValue - Emit code to compute a designator that specifies the location 502/// of the expression. 503/// 504/// This can return one of two things: a simple address or a bitfield reference. 505/// In either case, the LLVM Value* in the LValue structure is guaranteed to be 506/// an LLVM pointer type. 507/// 508/// If this returns a bitfield reference, nothing about the pointee type of the 509/// LLVM value is known: For example, it may not be a pointer to an integer. 510/// 511/// If this returns a normal address, and if the lvalue's C type is fixed size, 512/// this method guarantees that the returned pointer type will point to an LLVM 513/// type of the same size of the lvalue's type. If the lvalue has a variable 514/// length type, this is not possible. 515/// 516LValue CodeGenFunction::EmitLValue(const Expr *E) { 517 switch (E->getStmtClass()) { 518 default: return EmitUnsupportedLValue(E, "l-value expression"); 519 520 case Expr::ObjCSelectorExprClass: 521 return EmitObjCSelectorLValue(cast<ObjCSelectorExpr>(E)); 522 case Expr::ObjCIsaExprClass: 523 return EmitObjCIsaExpr(cast<ObjCIsaExpr>(E)); 524 case Expr::BinaryOperatorClass: 525 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E)); 526 case Expr::CompoundAssignOperatorClass: 527 if (!E->getType()->isAnyComplexType()) 528 return EmitCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); 529 return EmitComplexCompoundAssignmentLValue(cast<CompoundAssignOperator>(E)); 530 case Expr::CallExprClass: 531 case Expr::CXXMemberCallExprClass: 532 case Expr::CXXOperatorCallExprClass: 533 return EmitCallExprLValue(cast<CallExpr>(E)); 534 case Expr::VAArgExprClass: 535 return EmitVAArgExprLValue(cast<VAArgExpr>(E)); 536 case Expr::DeclRefExprClass: 537 return EmitDeclRefLValue(cast<DeclRefExpr>(E)); 538 case Expr::ParenExprClass:return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 539 case Expr::PredefinedExprClass: 540 return EmitPredefinedLValue(cast<PredefinedExpr>(E)); 541 case Expr::StringLiteralClass: 542 return EmitStringLiteralLValue(cast<StringLiteral>(E)); 543 case Expr::ObjCEncodeExprClass: 544 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E)); 545 546 case Expr::BlockDeclRefExprClass: 547 return EmitBlockDeclRefLValue(cast<BlockDeclRefExpr>(E)); 548 549 case Expr::CXXTemporaryObjectExprClass: 550 case Expr::CXXConstructExprClass: 551 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E)); 552 case Expr::CXXBindTemporaryExprClass: 553 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E)); 554 case Expr::ExprWithCleanupsClass: 555 return EmitExprWithCleanupsLValue(cast<ExprWithCleanups>(E)); 556 case Expr::CXXScalarValueInitExprClass: 557 return EmitNullInitializationLValue(cast<CXXScalarValueInitExpr>(E)); 558 case Expr::CXXDefaultArgExprClass: 559 return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr()); 560 case Expr::CXXTypeidExprClass: 561 return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E)); 562 563 case Expr::ObjCMessageExprClass: 564 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E)); 565 case Expr::ObjCIvarRefExprClass: 566 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E)); 567 case Expr::ObjCPropertyRefExprClass: 568 return EmitObjCPropertyRefLValue(cast<ObjCPropertyRefExpr>(E)); 569 case Expr::StmtExprClass: 570 return EmitStmtExprLValue(cast<StmtExpr>(E)); 571 case Expr::UnaryOperatorClass: 572 return EmitUnaryOpLValue(cast<UnaryOperator>(E)); 573 case Expr::ArraySubscriptExprClass: 574 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E)); 575 case Expr::ExtVectorElementExprClass: 576 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E)); 577 case Expr::MemberExprClass: 578 return EmitMemberExpr(cast<MemberExpr>(E)); 579 case Expr::CompoundLiteralExprClass: 580 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E)); 581 case Expr::ConditionalOperatorClass: 582 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E)); 583 case Expr::BinaryConditionalOperatorClass: 584 return EmitConditionalOperatorLValue(cast<BinaryConditionalOperator>(E)); 585 case Expr::ChooseExprClass: 586 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext())); 587 case Expr::OpaqueValueExprClass: 588 return EmitOpaqueValueLValue(cast<OpaqueValueExpr>(E)); 589 case Expr::ImplicitCastExprClass: 590 case Expr::CStyleCastExprClass: 591 case Expr::CXXFunctionalCastExprClass: 592 case Expr::CXXStaticCastExprClass: 593 case Expr::CXXDynamicCastExprClass: 594 case Expr::CXXReinterpretCastExprClass: 595 case Expr::CXXConstCastExprClass: 596 return EmitCastLValue(cast<CastExpr>(E)); 597 } 598} 599 600llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile, 601 unsigned Alignment, QualType Ty, 602 llvm::MDNode *TBAAInfo) { 603 llvm::LoadInst *Load = Builder.CreateLoad(Addr, "tmp"); 604 if (Volatile) 605 Load->setVolatile(true); 606 if (Alignment) 607 Load->setAlignment(Alignment); 608 if (TBAAInfo) 609 CGM.DecorateInstruction(Load, TBAAInfo); 610 611 return EmitFromMemory(Load, Ty); 612} 613 614static bool isBooleanUnderlyingType(QualType Ty) { 615 if (const EnumType *ET = dyn_cast<EnumType>(Ty)) 616 return ET->getDecl()->getIntegerType()->isBooleanType(); 617 return false; 618} 619 620llvm::Value *CodeGenFunction::EmitToMemory(llvm::Value *Value, QualType Ty) { 621 // Bool has a different representation in memory than in registers. 622 if (Ty->isBooleanType() || isBooleanUnderlyingType(Ty)) { 623 // This should really always be an i1, but sometimes it's already 624 // an i8, and it's awkward to track those cases down. 625 if (Value->getType()->isIntegerTy(1)) 626 return Builder.CreateZExt(Value, Builder.getInt8Ty(), "frombool"); 627 assert(Value->getType()->isIntegerTy(8) && "value rep of bool not i1/i8"); 628 } 629 630 return Value; 631} 632 633llvm::Value *CodeGenFunction::EmitFromMemory(llvm::Value *Value, QualType Ty) { 634 // Bool has a different representation in memory than in registers. 635 if (Ty->isBooleanType() || isBooleanUnderlyingType(Ty)) { 636 assert(Value->getType()->isIntegerTy(8) && "memory rep of bool not i8"); 637 return Builder.CreateTrunc(Value, Builder.getInt1Ty(), "tobool"); 638 } 639 640 return Value; 641} 642 643void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr, 644 bool Volatile, unsigned Alignment, 645 QualType Ty, 646 llvm::MDNode *TBAAInfo) { 647 Value = EmitToMemory(Value, Ty); 648 llvm::StoreInst *Store = Builder.CreateStore(Value, Addr, Volatile); 649 if (Alignment) 650 Store->setAlignment(Alignment); 651 if (TBAAInfo) 652 CGM.DecorateInstruction(Store, TBAAInfo); 653} 654 655/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this 656/// method emits the address of the lvalue, then loads the result as an rvalue, 657/// returning the rvalue. 658RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, QualType ExprType) { 659 if (LV.isObjCWeak()) { 660 // load of a __weak object. 661 llvm::Value *AddrWeakObj = LV.getAddress(); 662 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this, 663 AddrWeakObj)); 664 } 665 666 if (LV.isSimple()) { 667 llvm::Value *Ptr = LV.getAddress(); 668 669 // Functions are l-values that don't require loading. 670 if (ExprType->isFunctionType()) 671 return RValue::get(Ptr); 672 673 // Everything needs a load. 674 return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(), 675 LV.getAlignment(), ExprType, 676 LV.getTBAAInfo())); 677 678 } 679 680 if (LV.isVectorElt()) { 681 llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(), 682 LV.isVolatileQualified(), "tmp"); 683 return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(), 684 "vecext")); 685 } 686 687 // If this is a reference to a subset of the elements of a vector, either 688 // shuffle the input or extract/insert them as appropriate. 689 if (LV.isExtVectorElt()) 690 return EmitLoadOfExtVectorElementLValue(LV, ExprType); 691 692 if (LV.isBitField()) 693 return EmitLoadOfBitfieldLValue(LV, ExprType); 694 695 assert(LV.isPropertyRef() && "Unknown LValue type!"); 696 return EmitLoadOfPropertyRefLValue(LV); 697} 698 699RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV, 700 QualType ExprType) { 701 const CGBitFieldInfo &Info = LV.getBitFieldInfo(); 702 703 // Get the output type. 704 const llvm::Type *ResLTy = ConvertType(ExprType); 705 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy); 706 707 // Compute the result as an OR of all of the individual component accesses. 708 llvm::Value *Res = 0; 709 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) { 710 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i); 711 712 // Get the field pointer. 713 llvm::Value *Ptr = LV.getBitFieldBaseAddr(); 714 715 // Only offset by the field index if used, so that incoming values are not 716 // required to be structures. 717 if (AI.FieldIndex) 718 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field"); 719 720 // Offset by the byte offset, if used. 721 if (AI.FieldByteOffset) { 722 Ptr = EmitCastToVoidPtr(Ptr); 723 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset,"bf.field.offs"); 724 } 725 726 // Cast to the access type. 727 const llvm::Type *PTy = llvm::Type::getIntNPtrTy(getLLVMContext(), 728 AI.AccessWidth, 729 CGM.getContext().getTargetAddressSpace(ExprType)); 730 Ptr = Builder.CreateBitCast(Ptr, PTy); 731 732 // Perform the load. 733 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, LV.isVolatileQualified()); 734 if (AI.AccessAlignment) 735 Load->setAlignment(AI.AccessAlignment); 736 737 // Shift out unused low bits and mask out unused high bits. 738 llvm::Value *Val = Load; 739 if (AI.FieldBitStart) 740 Val = Builder.CreateLShr(Load, AI.FieldBitStart); 741 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(AI.AccessWidth, 742 AI.TargetBitWidth), 743 "bf.clear"); 744 745 // Extend or truncate to the target size. 746 if (AI.AccessWidth < ResSizeInBits) 747 Val = Builder.CreateZExt(Val, ResLTy); 748 else if (AI.AccessWidth > ResSizeInBits) 749 Val = Builder.CreateTrunc(Val, ResLTy); 750 751 // Shift into place, and OR into the result. 752 if (AI.TargetBitOffset) 753 Val = Builder.CreateShl(Val, AI.TargetBitOffset); 754 Res = Res ? Builder.CreateOr(Res, Val) : Val; 755 } 756 757 // If the bit-field is signed, perform the sign-extension. 758 // 759 // FIXME: This can easily be folded into the load of the high bits, which 760 // could also eliminate the mask of high bits in some situations. 761 if (Info.isSigned()) { 762 unsigned ExtraBits = ResSizeInBits - Info.getSize(); 763 if (ExtraBits) 764 Res = Builder.CreateAShr(Builder.CreateShl(Res, ExtraBits), 765 ExtraBits, "bf.val.sext"); 766 } 767 768 return RValue::get(Res); 769} 770 771// If this is a reference to a subset of the elements of a vector, create an 772// appropriate shufflevector. 773RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV, 774 QualType ExprType) { 775 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(), 776 LV.isVolatileQualified(), "tmp"); 777 778 const llvm::Constant *Elts = LV.getExtVectorElts(); 779 780 // If the result of the expression is a non-vector type, we must be extracting 781 // a single element. Just codegen as an extractelement. 782 const VectorType *ExprVT = ExprType->getAs<VectorType>(); 783 if (!ExprVT) { 784 unsigned InIdx = getAccessedFieldNo(0, Elts); 785 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx); 786 return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp")); 787 } 788 789 // Always use shuffle vector to try to retain the original program structure 790 unsigned NumResultElts = ExprVT->getNumElements(); 791 792 llvm::SmallVector<llvm::Constant*, 4> Mask; 793 for (unsigned i = 0; i != NumResultElts; ++i) { 794 unsigned InIdx = getAccessedFieldNo(i, Elts); 795 Mask.push_back(llvm::ConstantInt::get(Int32Ty, InIdx)); 796 } 797 798 llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 799 Vec = Builder.CreateShuffleVector(Vec, llvm::UndefValue::get(Vec->getType()), 800 MaskV, "tmp"); 801 return RValue::get(Vec); 802} 803 804 805 806/// EmitStoreThroughLValue - Store the specified rvalue into the specified 807/// lvalue, where both are guaranteed to the have the same type, and that type 808/// is 'Ty'. 809void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, 810 QualType Ty) { 811 if (!Dst.isSimple()) { 812 if (Dst.isVectorElt()) { 813 // Read/modify/write the vector, inserting the new element. 814 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(), 815 Dst.isVolatileQualified(), "tmp"); 816 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), 817 Dst.getVectorIdx(), "vecins"); 818 Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified()); 819 return; 820 } 821 822 // If this is an update of extended vector elements, insert them as 823 // appropriate. 824 if (Dst.isExtVectorElt()) 825 return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty); 826 827 if (Dst.isBitField()) 828 return EmitStoreThroughBitfieldLValue(Src, Dst, Ty); 829 830 assert(Dst.isPropertyRef() && "Unknown LValue type"); 831 return EmitStoreThroughPropertyRefLValue(Src, Dst); 832 } 833 834 if (Dst.isObjCWeak() && !Dst.isNonGC()) { 835 // load of a __weak object. 836 llvm::Value *LvalueDst = Dst.getAddress(); 837 llvm::Value *src = Src.getScalarVal(); 838 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst); 839 return; 840 } 841 842 if (Dst.isObjCStrong() && !Dst.isNonGC()) { 843 // load of a __strong object. 844 llvm::Value *LvalueDst = Dst.getAddress(); 845 llvm::Value *src = Src.getScalarVal(); 846 if (Dst.isObjCIvar()) { 847 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL"); 848 const llvm::Type *ResultType = ConvertType(getContext().LongTy); 849 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp()); 850 llvm::Value *dst = RHS; 851 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 852 llvm::Value *LHS = 853 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast"); 854 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset"); 855 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst, 856 BytesBetween); 857 } else if (Dst.isGlobalObjCRef()) { 858 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst, 859 Dst.isThreadLocalRef()); 860 } 861 else 862 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst); 863 return; 864 } 865 866 assert(Src.isScalar() && "Can't emit an agg store with this method"); 867 EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(), 868 Dst.isVolatileQualified(), Dst.getAlignment(), Ty, 869 Dst.getTBAAInfo()); 870} 871 872void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 873 QualType Ty, 874 llvm::Value **Result) { 875 const CGBitFieldInfo &Info = Dst.getBitFieldInfo(); 876 877 // Get the output type. 878 const llvm::Type *ResLTy = ConvertTypeForMem(Ty); 879 unsigned ResSizeInBits = CGM.getTargetData().getTypeSizeInBits(ResLTy); 880 881 // Get the source value, truncated to the width of the bit-field. 882 llvm::Value *SrcVal = Src.getScalarVal(); 883 884 if (Ty->isBooleanType()) 885 SrcVal = Builder.CreateIntCast(SrcVal, ResLTy, /*IsSigned=*/false); 886 887 SrcVal = Builder.CreateAnd(SrcVal, llvm::APInt::getLowBitsSet(ResSizeInBits, 888 Info.getSize()), 889 "bf.value"); 890 891 // Return the new value of the bit-field, if requested. 892 if (Result) { 893 // Cast back to the proper type for result. 894 const llvm::Type *SrcTy = Src.getScalarVal()->getType(); 895 llvm::Value *ReloadVal = Builder.CreateIntCast(SrcVal, SrcTy, false, 896 "bf.reload.val"); 897 898 // Sign extend if necessary. 899 if (Info.isSigned()) { 900 unsigned ExtraBits = ResSizeInBits - Info.getSize(); 901 if (ExtraBits) 902 ReloadVal = Builder.CreateAShr(Builder.CreateShl(ReloadVal, ExtraBits), 903 ExtraBits, "bf.reload.sext"); 904 } 905 906 *Result = ReloadVal; 907 } 908 909 // Iterate over the components, writing each piece to memory. 910 for (unsigned i = 0, e = Info.getNumComponents(); i != e; ++i) { 911 const CGBitFieldInfo::AccessInfo &AI = Info.getComponent(i); 912 913 // Get the field pointer. 914 llvm::Value *Ptr = Dst.getBitFieldBaseAddr(); 915 unsigned addressSpace = 916 cast<llvm::PointerType>(Ptr->getType())->getAddressSpace(); 917 918 // Only offset by the field index if used, so that incoming values are not 919 // required to be structures. 920 if (AI.FieldIndex) 921 Ptr = Builder.CreateStructGEP(Ptr, AI.FieldIndex, "bf.field"); 922 923 // Offset by the byte offset, if used. 924 if (AI.FieldByteOffset) { 925 Ptr = EmitCastToVoidPtr(Ptr); 926 Ptr = Builder.CreateConstGEP1_32(Ptr, AI.FieldByteOffset,"bf.field.offs"); 927 } 928 929 // Cast to the access type. 930 const llvm::Type *AccessLTy = 931 llvm::Type::getIntNTy(getLLVMContext(), AI.AccessWidth); 932 933 const llvm::Type *PTy = AccessLTy->getPointerTo(addressSpace); 934 Ptr = Builder.CreateBitCast(Ptr, PTy); 935 936 // Extract the piece of the bit-field value to write in this access, limited 937 // to the values that are part of this access. 938 llvm::Value *Val = SrcVal; 939 if (AI.TargetBitOffset) 940 Val = Builder.CreateLShr(Val, AI.TargetBitOffset); 941 Val = Builder.CreateAnd(Val, llvm::APInt::getLowBitsSet(ResSizeInBits, 942 AI.TargetBitWidth)); 943 944 // Extend or truncate to the access size. 945 if (ResSizeInBits < AI.AccessWidth) 946 Val = Builder.CreateZExt(Val, AccessLTy); 947 else if (ResSizeInBits > AI.AccessWidth) 948 Val = Builder.CreateTrunc(Val, AccessLTy); 949 950 // Shift into the position in memory. 951 if (AI.FieldBitStart) 952 Val = Builder.CreateShl(Val, AI.FieldBitStart); 953 954 // If necessary, load and OR in bits that are outside of the bit-field. 955 if (AI.TargetBitWidth != AI.AccessWidth) { 956 llvm::LoadInst *Load = Builder.CreateLoad(Ptr, Dst.isVolatileQualified()); 957 if (AI.AccessAlignment) 958 Load->setAlignment(AI.AccessAlignment); 959 960 // Compute the mask for zeroing the bits that are part of the bit-field. 961 llvm::APInt InvMask = 962 ~llvm::APInt::getBitsSet(AI.AccessWidth, AI.FieldBitStart, 963 AI.FieldBitStart + AI.TargetBitWidth); 964 965 // Apply the mask and OR in to the value to write. 966 Val = Builder.CreateOr(Builder.CreateAnd(Load, InvMask), Val); 967 } 968 969 // Write the value. 970 llvm::StoreInst *Store = Builder.CreateStore(Val, Ptr, 971 Dst.isVolatileQualified()); 972 if (AI.AccessAlignment) 973 Store->setAlignment(AI.AccessAlignment); 974 } 975} 976 977void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, 978 LValue Dst, 979 QualType Ty) { 980 // This access turns into a read/modify/write of the vector. Load the input 981 // value now. 982 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(), 983 Dst.isVolatileQualified(), "tmp"); 984 const llvm::Constant *Elts = Dst.getExtVectorElts(); 985 986 llvm::Value *SrcVal = Src.getScalarVal(); 987 988 if (const VectorType *VTy = Ty->getAs<VectorType>()) { 989 unsigned NumSrcElts = VTy->getNumElements(); 990 unsigned NumDstElts = 991 cast<llvm::VectorType>(Vec->getType())->getNumElements(); 992 if (NumDstElts == NumSrcElts) { 993 // Use shuffle vector is the src and destination are the same number of 994 // elements and restore the vector mask since it is on the side it will be 995 // stored. 996 llvm::SmallVector<llvm::Constant*, 4> Mask(NumDstElts); 997 for (unsigned i = 0; i != NumSrcElts; ++i) { 998 unsigned InIdx = getAccessedFieldNo(i, Elts); 999 Mask[InIdx] = llvm::ConstantInt::get(Int32Ty, i); 1000 } 1001 1002 llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 1003 Vec = Builder.CreateShuffleVector(SrcVal, 1004 llvm::UndefValue::get(Vec->getType()), 1005 MaskV, "tmp"); 1006 } else if (NumDstElts > NumSrcElts) { 1007 // Extended the source vector to the same length and then shuffle it 1008 // into the destination. 1009 // FIXME: since we're shuffling with undef, can we just use the indices 1010 // into that? This could be simpler. 1011 llvm::SmallVector<llvm::Constant*, 4> ExtMask; 1012 unsigned i; 1013 for (i = 0; i != NumSrcElts; ++i) 1014 ExtMask.push_back(llvm::ConstantInt::get(Int32Ty, i)); 1015 for (; i != NumDstElts; ++i) 1016 ExtMask.push_back(llvm::UndefValue::get(Int32Ty)); 1017 llvm::Value *ExtMaskV = llvm::ConstantVector::get(ExtMask); 1018 llvm::Value *ExtSrcVal = 1019 Builder.CreateShuffleVector(SrcVal, 1020 llvm::UndefValue::get(SrcVal->getType()), 1021 ExtMaskV, "tmp"); 1022 // build identity 1023 llvm::SmallVector<llvm::Constant*, 4> Mask; 1024 for (unsigned i = 0; i != NumDstElts; ++i) 1025 Mask.push_back(llvm::ConstantInt::get(Int32Ty, i)); 1026 1027 // modify when what gets shuffled in 1028 for (unsigned i = 0; i != NumSrcElts; ++i) { 1029 unsigned Idx = getAccessedFieldNo(i, Elts); 1030 Mask[Idx] = llvm::ConstantInt::get(Int32Ty, i+NumDstElts); 1031 } 1032 llvm::Value *MaskV = llvm::ConstantVector::get(Mask); 1033 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp"); 1034 } else { 1035 // We should never shorten the vector 1036 assert(0 && "unexpected shorten vector length"); 1037 } 1038 } else { 1039 // If the Src is a scalar (not a vector) it must be updating one element. 1040 unsigned InIdx = getAccessedFieldNo(0, Elts); 1041 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx); 1042 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp"); 1043 } 1044 1045 Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified()); 1046} 1047 1048// setObjCGCLValueClass - sets class of he lvalue for the purpose of 1049// generating write-barries API. It is currently a global, ivar, 1050// or neither. 1051static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E, 1052 LValue &LV) { 1053 if (Ctx.getLangOptions().getGCMode() == LangOptions::NonGC) 1054 return; 1055 1056 if (isa<ObjCIvarRefExpr>(E)) { 1057 LV.setObjCIvar(true); 1058 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E)); 1059 LV.setBaseIvarExp(Exp->getBase()); 1060 LV.setObjCArray(E->getType()->isArrayType()); 1061 return; 1062 } 1063 1064 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) { 1065 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) { 1066 if (VD->hasGlobalStorage()) { 1067 LV.setGlobalObjCRef(true); 1068 LV.setThreadLocalRef(VD->isThreadSpecified()); 1069 } 1070 } 1071 LV.setObjCArray(E->getType()->isArrayType()); 1072 return; 1073 } 1074 1075 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) { 1076 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1077 return; 1078 } 1079 1080 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) { 1081 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1082 if (LV.isObjCIvar()) { 1083 // If cast is to a structure pointer, follow gcc's behavior and make it 1084 // a non-ivar write-barrier. 1085 QualType ExpTy = E->getType(); 1086 if (ExpTy->isPointerType()) 1087 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); 1088 if (ExpTy->isRecordType()) 1089 LV.setObjCIvar(false); 1090 } 1091 return; 1092 } 1093 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) { 1094 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1095 return; 1096 } 1097 1098 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) { 1099 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1100 return; 1101 } 1102 1103 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) { 1104 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 1105 if (LV.isObjCIvar() && !LV.isObjCArray()) 1106 // Using array syntax to assigning to what an ivar points to is not 1107 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0; 1108 LV.setObjCIvar(false); 1109 else if (LV.isGlobalObjCRef() && !LV.isObjCArray()) 1110 // Using array syntax to assigning to what global points to is not 1111 // same as assigning to the global itself. {id *G;} G[i] = 0; 1112 LV.setGlobalObjCRef(false); 1113 return; 1114 } 1115 1116 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) { 1117 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 1118 // We don't know if member is an 'ivar', but this flag is looked at 1119 // only in the context of LV.isObjCIvar(). 1120 LV.setObjCArray(E->getType()->isArrayType()); 1121 return; 1122 } 1123} 1124 1125static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF, 1126 const Expr *E, const VarDecl *VD) { 1127 assert((VD->hasExternalStorage() || VD->isFileVarDecl()) && 1128 "Var decl must have external storage or be a file var decl!"); 1129 1130 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD); 1131 if (VD->getType()->isReferenceType()) 1132 V = CGF.Builder.CreateLoad(V, "tmp"); 1133 unsigned Alignment = CGF.getContext().getDeclAlign(VD).getQuantity(); 1134 LValue LV = CGF.MakeAddrLValue(V, E->getType(), Alignment); 1135 setObjCGCLValueClass(CGF.getContext(), E, LV); 1136 return LV; 1137} 1138 1139static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF, 1140 const Expr *E, const FunctionDecl *FD) { 1141 llvm::Value *V = CGF.CGM.GetAddrOfFunction(FD); 1142 if (!FD->hasPrototype()) { 1143 if (const FunctionProtoType *Proto = 1144 FD->getType()->getAs<FunctionProtoType>()) { 1145 // Ugly case: for a K&R-style definition, the type of the definition 1146 // isn't the same as the type of a use. Correct for this with a 1147 // bitcast. 1148 QualType NoProtoType = 1149 CGF.getContext().getFunctionNoProtoType(Proto->getResultType()); 1150 NoProtoType = CGF.getContext().getPointerType(NoProtoType); 1151 V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType), "tmp"); 1152 } 1153 } 1154 unsigned Alignment = CGF.getContext().getDeclAlign(FD).getQuantity(); 1155 return CGF.MakeAddrLValue(V, E->getType(), Alignment); 1156} 1157 1158LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { 1159 const NamedDecl *ND = E->getDecl(); 1160 unsigned Alignment = getContext().getDeclAlign(ND).getQuantity(); 1161 1162 if (ND->hasAttr<WeakRefAttr>()) { 1163 const ValueDecl *VD = cast<ValueDecl>(ND); 1164 llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD); 1165 return MakeAddrLValue(Aliasee, E->getType(), Alignment); 1166 } 1167 1168 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) { 1169 1170 // Check if this is a global variable. 1171 if (VD->hasExternalStorage() || VD->isFileVarDecl()) 1172 return EmitGlobalVarDeclLValue(*this, E, VD); 1173 1174 bool NonGCable = VD->hasLocalStorage() && 1175 !VD->getType()->isReferenceType() && 1176 !VD->hasAttr<BlocksAttr>(); 1177 1178 llvm::Value *V = LocalDeclMap[VD]; 1179 if (!V && VD->isStaticLocal()) 1180 V = CGM.getStaticLocalDeclAddress(VD); 1181 assert(V && "DeclRefExpr not entered in LocalDeclMap?"); 1182 1183 if (VD->hasAttr<BlocksAttr>()) 1184 V = BuildBlockByrefAddress(V, VD); 1185 1186 if (VD->getType()->isReferenceType()) 1187 V = Builder.CreateLoad(V, "tmp"); 1188 1189 LValue LV = MakeAddrLValue(V, E->getType(), Alignment); 1190 if (NonGCable) { 1191 LV.getQuals().removeObjCGCAttr(); 1192 LV.setNonGC(true); 1193 } 1194 setObjCGCLValueClass(getContext(), E, LV); 1195 return LV; 1196 } 1197 1198 if (const FunctionDecl *fn = dyn_cast<FunctionDecl>(ND)) 1199 return EmitFunctionDeclLValue(*this, E, fn); 1200 1201 assert(false && "Unhandled DeclRefExpr"); 1202 1203 // an invalid LValue, but the assert will 1204 // ensure that this point is never reached. 1205 return LValue(); 1206} 1207 1208LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) { 1209 unsigned Alignment = 1210 getContext().getDeclAlign(E->getDecl()).getQuantity(); 1211 return MakeAddrLValue(GetAddrOfBlockDecl(E), E->getType(), Alignment); 1212} 1213 1214LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { 1215 // __extension__ doesn't affect lvalue-ness. 1216 if (E->getOpcode() == UO_Extension) 1217 return EmitLValue(E->getSubExpr()); 1218 1219 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType()); 1220 switch (E->getOpcode()) { 1221 default: assert(0 && "Unknown unary operator lvalue!"); 1222 case UO_Deref: { 1223 QualType T = E->getSubExpr()->getType()->getPointeeType(); 1224 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type"); 1225 1226 LValue LV = MakeAddrLValue(EmitScalarExpr(E->getSubExpr()), T); 1227 LV.getQuals().setAddressSpace(ExprTy.getAddressSpace()); 1228 1229 // We should not generate __weak write barrier on indirect reference 1230 // of a pointer to object; as in void foo (__weak id *param); *param = 0; 1231 // But, we continue to generate __strong write barrier on indirect write 1232 // into a pointer to object. 1233 if (getContext().getLangOptions().ObjC1 && 1234 getContext().getLangOptions().getGCMode() != LangOptions::NonGC && 1235 LV.isObjCWeak()) 1236 LV.setNonGC(!E->isOBJCGCCandidate(getContext())); 1237 return LV; 1238 } 1239 case UO_Real: 1240 case UO_Imag: { 1241 LValue LV = EmitLValue(E->getSubExpr()); 1242 assert(LV.isSimple() && "real/imag on non-ordinary l-value"); 1243 llvm::Value *Addr = LV.getAddress(); 1244 1245 // real and imag are valid on scalars. This is a faster way of 1246 // testing that. 1247 if (!cast<llvm::PointerType>(Addr->getType()) 1248 ->getElementType()->isStructTy()) { 1249 assert(E->getSubExpr()->getType()->isArithmeticType()); 1250 return LV; 1251 } 1252 1253 assert(E->getSubExpr()->getType()->isAnyComplexType()); 1254 1255 unsigned Idx = E->getOpcode() == UO_Imag; 1256 return MakeAddrLValue(Builder.CreateStructGEP(LV.getAddress(), 1257 Idx, "idx"), 1258 ExprTy); 1259 } 1260 case UO_PreInc: 1261 case UO_PreDec: { 1262 LValue LV = EmitLValue(E->getSubExpr()); 1263 bool isInc = E->getOpcode() == UO_PreInc; 1264 1265 if (E->getType()->isAnyComplexType()) 1266 EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/); 1267 else 1268 EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/); 1269 return LV; 1270 } 1271 } 1272} 1273 1274LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { 1275 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromLiteral(E), 1276 E->getType()); 1277} 1278 1279LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) { 1280 return MakeAddrLValue(CGM.GetAddrOfConstantStringFromObjCEncode(E), 1281 E->getType()); 1282} 1283 1284 1285LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { 1286 switch (E->getIdentType()) { 1287 default: 1288 return EmitUnsupportedLValue(E, "predefined expression"); 1289 1290 case PredefinedExpr::Func: 1291 case PredefinedExpr::Function: 1292 case PredefinedExpr::PrettyFunction: { 1293 unsigned Type = E->getIdentType(); 1294 std::string GlobalVarName; 1295 1296 switch (Type) { 1297 default: assert(0 && "Invalid type"); 1298 case PredefinedExpr::Func: 1299 GlobalVarName = "__func__."; 1300 break; 1301 case PredefinedExpr::Function: 1302 GlobalVarName = "__FUNCTION__."; 1303 break; 1304 case PredefinedExpr::PrettyFunction: 1305 GlobalVarName = "__PRETTY_FUNCTION__."; 1306 break; 1307 } 1308 1309 llvm::StringRef FnName = CurFn->getName(); 1310 if (FnName.startswith("\01")) 1311 FnName = FnName.substr(1); 1312 GlobalVarName += FnName; 1313 1314 const Decl *CurDecl = CurCodeDecl; 1315 if (CurDecl == 0) 1316 CurDecl = getContext().getTranslationUnitDecl(); 1317 1318 std::string FunctionName = 1319 (isa<BlockDecl>(CurDecl) 1320 ? FnName.str() 1321 : PredefinedExpr::ComputeName((PredefinedExpr::IdentType)Type, CurDecl)); 1322 1323 llvm::Constant *C = 1324 CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str()); 1325 return MakeAddrLValue(C, E->getType()); 1326 } 1327 } 1328} 1329 1330llvm::BasicBlock *CodeGenFunction::getTrapBB() { 1331 const CodeGenOptions &GCO = CGM.getCodeGenOpts(); 1332 1333 // If we are not optimzing, don't collapse all calls to trap in the function 1334 // to the same call, that way, in the debugger they can see which operation 1335 // did in fact fail. If we are optimizing, we collapse all calls to trap down 1336 // to just one per function to save on codesize. 1337 if (GCO.OptimizationLevel && TrapBB) 1338 return TrapBB; 1339 1340 llvm::BasicBlock *Cont = 0; 1341 if (HaveInsertPoint()) { 1342 Cont = createBasicBlock("cont"); 1343 EmitBranch(Cont); 1344 } 1345 TrapBB = createBasicBlock("trap"); 1346 EmitBlock(TrapBB); 1347 1348 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap, 0, 0); 1349 llvm::CallInst *TrapCall = Builder.CreateCall(F); 1350 TrapCall->setDoesNotReturn(); 1351 TrapCall->setDoesNotThrow(); 1352 Builder.CreateUnreachable(); 1353 1354 if (Cont) 1355 EmitBlock(Cont); 1356 return TrapBB; 1357} 1358 1359/// isSimpleArrayDecayOperand - If the specified expr is a simple decay from an 1360/// array to pointer, return the array subexpression. 1361static const Expr *isSimpleArrayDecayOperand(const Expr *E) { 1362 // If this isn't just an array->pointer decay, bail out. 1363 const CastExpr *CE = dyn_cast<CastExpr>(E); 1364 if (CE == 0 || CE->getCastKind() != CK_ArrayToPointerDecay) 1365 return 0; 1366 1367 // If this is a decay from variable width array, bail out. 1368 const Expr *SubExpr = CE->getSubExpr(); 1369 if (SubExpr->getType()->isVariableArrayType()) 1370 return 0; 1371 1372 return SubExpr; 1373} 1374 1375LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { 1376 // The index must always be an integer, which is not an aggregate. Emit it. 1377 llvm::Value *Idx = EmitScalarExpr(E->getIdx()); 1378 QualType IdxTy = E->getIdx()->getType(); 1379 bool IdxSigned = IdxTy->isSignedIntegerType(); 1380 1381 // If the base is a vector type, then we are forming a vector element lvalue 1382 // with this subscript. 1383 if (E->getBase()->getType()->isVectorType()) { 1384 // Emit the vector as an lvalue to get its address. 1385 LValue LHS = EmitLValue(E->getBase()); 1386 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 1387 Idx = Builder.CreateIntCast(Idx, Int32Ty, IdxSigned, "vidx"); 1388 return LValue::MakeVectorElt(LHS.getAddress(), Idx, 1389 E->getBase()->getType().getCVRQualifiers()); 1390 } 1391 1392 // Extend or truncate the index type to 32 or 64-bits. 1393 if (Idx->getType() != IntPtrTy) 1394 Idx = Builder.CreateIntCast(Idx, IntPtrTy, IdxSigned, "idxprom"); 1395 1396 // FIXME: As llvm implements the object size checking, this can come out. 1397 if (CatchUndefined) { 1398 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E->getBase())){ 1399 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) { 1400 if (ICE->getCastKind() == CK_ArrayToPointerDecay) { 1401 if (const ConstantArrayType *CAT 1402 = getContext().getAsConstantArrayType(DRE->getType())) { 1403 llvm::APInt Size = CAT->getSize(); 1404 llvm::BasicBlock *Cont = createBasicBlock("cont"); 1405 Builder.CreateCondBr(Builder.CreateICmpULE(Idx, 1406 llvm::ConstantInt::get(Idx->getType(), Size)), 1407 Cont, getTrapBB()); 1408 EmitBlock(Cont); 1409 } 1410 } 1411 } 1412 } 1413 } 1414 1415 // We know that the pointer points to a type of the correct size, unless the 1416 // size is a VLA or Objective-C interface. 1417 llvm::Value *Address = 0; 1418 if (const VariableArrayType *VAT = 1419 getContext().getAsVariableArrayType(E->getType())) { 1420 llvm::Value *VLASize = GetVLASize(VAT); 1421 1422 Idx = Builder.CreateMul(Idx, VLASize); 1423 1424 // The base must be a pointer, which is not an aggregate. Emit it. 1425 llvm::Value *Base = EmitScalarExpr(E->getBase()); 1426 1427 Address = EmitCastToVoidPtr(Base); 1428 if (getContext().getLangOptions().isSignedOverflowDefined()) 1429 Address = Builder.CreateGEP(Address, Idx, "arrayidx"); 1430 else 1431 Address = Builder.CreateInBoundsGEP(Address, Idx, "arrayidx"); 1432 Address = Builder.CreateBitCast(Address, Base->getType()); 1433 } else if (const ObjCObjectType *OIT = E->getType()->getAs<ObjCObjectType>()){ 1434 // Indexing over an interface, as in "NSString *P; P[4];" 1435 llvm::Value *InterfaceSize = 1436 llvm::ConstantInt::get(Idx->getType(), 1437 getContext().getTypeSizeInChars(OIT).getQuantity()); 1438 1439 Idx = Builder.CreateMul(Idx, InterfaceSize); 1440 1441 // The base must be a pointer, which is not an aggregate. Emit it. 1442 llvm::Value *Base = EmitScalarExpr(E->getBase()); 1443 Address = EmitCastToVoidPtr(Base); 1444 Address = Builder.CreateGEP(Address, Idx, "arrayidx"); 1445 Address = Builder.CreateBitCast(Address, Base->getType()); 1446 } else if (const Expr *Array = isSimpleArrayDecayOperand(E->getBase())) { 1447 // If this is A[i] where A is an array, the frontend will have decayed the 1448 // base to be a ArrayToPointerDecay implicit cast. While correct, it is 1449 // inefficient at -O0 to emit a "gep A, 0, 0" when codegen'ing it, then a 1450 // "gep x, i" here. Emit one "gep A, 0, i". 1451 assert(Array->getType()->isArrayType() && 1452 "Array to pointer decay must have array source type!"); 1453 llvm::Value *ArrayPtr = EmitLValue(Array).getAddress(); 1454 llvm::Value *Zero = llvm::ConstantInt::get(Int32Ty, 0); 1455 llvm::Value *Args[] = { Zero, Idx }; 1456 1457 if (getContext().getLangOptions().isSignedOverflowDefined()) 1458 Address = Builder.CreateGEP(ArrayPtr, Args, Args+2, "arrayidx"); 1459 else 1460 Address = Builder.CreateInBoundsGEP(ArrayPtr, Args, Args+2, "arrayidx"); 1461 } else { 1462 // The base must be a pointer, which is not an aggregate. Emit it. 1463 llvm::Value *Base = EmitScalarExpr(E->getBase()); 1464 if (getContext().getLangOptions().isSignedOverflowDefined()) 1465 Address = Builder.CreateGEP(Base, Idx, "arrayidx"); 1466 else 1467 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx"); 1468 } 1469 1470 QualType T = E->getBase()->getType()->getPointeeType(); 1471 assert(!T.isNull() && 1472 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type"); 1473 1474 LValue LV = MakeAddrLValue(Address, T); 1475 LV.getQuals().setAddressSpace(E->getBase()->getType().getAddressSpace()); 1476 1477 if (getContext().getLangOptions().ObjC1 && 1478 getContext().getLangOptions().getGCMode() != LangOptions::NonGC) { 1479 LV.setNonGC(!E->isOBJCGCCandidate(getContext())); 1480 setObjCGCLValueClass(getContext(), E, LV); 1481 } 1482 return LV; 1483} 1484 1485static 1486llvm::Constant *GenerateConstantVector(llvm::LLVMContext &VMContext, 1487 llvm::SmallVector<unsigned, 4> &Elts) { 1488 llvm::SmallVector<llvm::Constant*, 4> CElts; 1489 1490 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext); 1491 for (unsigned i = 0, e = Elts.size(); i != e; ++i) 1492 CElts.push_back(llvm::ConstantInt::get(Int32Ty, Elts[i])); 1493 1494 return llvm::ConstantVector::get(CElts); 1495} 1496 1497LValue CodeGenFunction:: 1498EmitExtVectorElementExpr(const ExtVectorElementExpr *E) { 1499 // Emit the base vector as an l-value. 1500 LValue Base; 1501 1502 // ExtVectorElementExpr's base can either be a vector or pointer to vector. 1503 if (E->isArrow()) { 1504 // If it is a pointer to a vector, emit the address and form an lvalue with 1505 // it. 1506 llvm::Value *Ptr = EmitScalarExpr(E->getBase()); 1507 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>(); 1508 Base = MakeAddrLValue(Ptr, PT->getPointeeType()); 1509 Base.getQuals().removeObjCGCAttr(); 1510 } else if (E->getBase()->isGLValue()) { 1511 // Otherwise, if the base is an lvalue ( as in the case of foo.x.x), 1512 // emit the base as an lvalue. 1513 assert(E->getBase()->getType()->isVectorType()); 1514 Base = EmitLValue(E->getBase()); 1515 } else { 1516 // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such. 1517 assert(E->getBase()->getType()->getAs<VectorType>() && 1518 "Result must be a vector"); 1519 llvm::Value *Vec = EmitScalarExpr(E->getBase()); 1520 1521 // Store the vector to memory (because LValue wants an address). 1522 llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType()); 1523 Builder.CreateStore(Vec, VecMem); 1524 Base = MakeAddrLValue(VecMem, E->getBase()->getType()); 1525 } 1526 1527 // Encode the element access list into a vector of unsigned indices. 1528 llvm::SmallVector<unsigned, 4> Indices; 1529 E->getEncodedElementAccess(Indices); 1530 1531 if (Base.isSimple()) { 1532 llvm::Constant *CV = GenerateConstantVector(getLLVMContext(), Indices); 1533 return LValue::MakeExtVectorElt(Base.getAddress(), CV, 1534 Base.getVRQualifiers()); 1535 } 1536 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!"); 1537 1538 llvm::Constant *BaseElts = Base.getExtVectorElts(); 1539 llvm::SmallVector<llvm::Constant *, 4> CElts; 1540 1541 for (unsigned i = 0, e = Indices.size(); i != e; ++i) { 1542 if (isa<llvm::ConstantAggregateZero>(BaseElts)) 1543 CElts.push_back(llvm::ConstantInt::get(Int32Ty, 0)); 1544 else 1545 CElts.push_back(cast<llvm::Constant>(BaseElts->getOperand(Indices[i]))); 1546 } 1547 llvm::Constant *CV = llvm::ConstantVector::get(CElts); 1548 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, 1549 Base.getVRQualifiers()); 1550} 1551 1552LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { 1553 bool isNonGC = false; 1554 Expr *BaseExpr = E->getBase(); 1555 llvm::Value *BaseValue = NULL; 1556 Qualifiers BaseQuals; 1557 1558 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 1559 if (E->isArrow()) { 1560 BaseValue = EmitScalarExpr(BaseExpr); 1561 const PointerType *PTy = 1562 BaseExpr->getType()->getAs<PointerType>(); 1563 BaseQuals = PTy->getPointeeType().getQualifiers(); 1564 } else { 1565 LValue BaseLV = EmitLValue(BaseExpr); 1566 if (BaseLV.isNonGC()) 1567 isNonGC = true; 1568 // FIXME: this isn't right for bitfields. 1569 BaseValue = BaseLV.getAddress(); 1570 QualType BaseTy = BaseExpr->getType(); 1571 BaseQuals = BaseTy.getQualifiers(); 1572 } 1573 1574 NamedDecl *ND = E->getMemberDecl(); 1575 if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) { 1576 LValue LV = EmitLValueForField(BaseValue, Field, 1577 BaseQuals.getCVRQualifiers()); 1578 LV.setNonGC(isNonGC); 1579 setObjCGCLValueClass(getContext(), E, LV); 1580 return LV; 1581 } 1582 1583 if (VarDecl *VD = dyn_cast<VarDecl>(ND)) 1584 return EmitGlobalVarDeclLValue(*this, E, VD); 1585 1586 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) 1587 return EmitFunctionDeclLValue(*this, E, FD); 1588 1589 assert(false && "Unhandled member declaration!"); 1590 return LValue(); 1591} 1592 1593LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value *BaseValue, 1594 const FieldDecl *Field, 1595 unsigned CVRQualifiers) { 1596 const CGRecordLayout &RL = 1597 CGM.getTypes().getCGRecordLayout(Field->getParent()); 1598 const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field); 1599 return LValue::MakeBitfield(BaseValue, Info, 1600 Field->getType().getCVRQualifiers()|CVRQualifiers); 1601} 1602 1603/// EmitLValueForAnonRecordField - Given that the field is a member of 1604/// an anonymous struct or union buried inside a record, and given 1605/// that the base value is a pointer to the enclosing record, derive 1606/// an lvalue for the ultimate field. 1607LValue CodeGenFunction::EmitLValueForAnonRecordField(llvm::Value *BaseValue, 1608 const IndirectFieldDecl *Field, 1609 unsigned CVRQualifiers) { 1610 IndirectFieldDecl::chain_iterator I = Field->chain_begin(), 1611 IEnd = Field->chain_end(); 1612 while (true) { 1613 LValue LV = EmitLValueForField(BaseValue, cast<FieldDecl>(*I), CVRQualifiers); 1614 if (++I == IEnd) return LV; 1615 1616 assert(LV.isSimple()); 1617 BaseValue = LV.getAddress(); 1618 CVRQualifiers |= LV.getVRQualifiers(); 1619 } 1620} 1621 1622LValue CodeGenFunction::EmitLValueForField(llvm::Value *baseAddr, 1623 const FieldDecl *field, 1624 unsigned cvr) { 1625 if (field->isBitField()) 1626 return EmitLValueForBitfield(baseAddr, field, cvr); 1627 1628 const RecordDecl *rec = field->getParent(); 1629 QualType type = field->getType(); 1630 1631 bool mayAlias = rec->hasAttr<MayAliasAttr>(); 1632 1633 llvm::Value *addr; 1634 if (rec->isUnion()) { 1635 // For unions, we just cast to the appropriate type. 1636 assert(!type->isReferenceType() && "union has reference member"); 1637 1638 const llvm::Type *llvmType = CGM.getTypes().ConvertTypeForMem(type); 1639 unsigned AS = 1640 cast<llvm::PointerType>(baseAddr->getType())->getAddressSpace(); 1641 addr = Builder.CreateBitCast(baseAddr, llvmType->getPointerTo(AS), 1642 field->getName()); 1643 } else { 1644 // For structs, we GEP to the field that the record layout suggests. 1645 unsigned idx = CGM.getTypes().getCGRecordLayout(rec).getLLVMFieldNo(field); 1646 addr = Builder.CreateStructGEP(baseAddr, idx, field->getName()); 1647 1648 // If this is a reference field, load the reference right now. 1649 if (const ReferenceType *refType = type->getAs<ReferenceType>()) { 1650 llvm::LoadInst *load = Builder.CreateLoad(addr, "ref"); 1651 if (cvr & Qualifiers::Volatile) load->setVolatile(true); 1652 1653 if (CGM.shouldUseTBAA()) { 1654 llvm::MDNode *tbaa; 1655 if (mayAlias) 1656 tbaa = CGM.getTBAAInfo(getContext().CharTy); 1657 else 1658 tbaa = CGM.getTBAAInfo(type); 1659 CGM.DecorateInstruction(load, tbaa); 1660 } 1661 1662 addr = load; 1663 mayAlias = false; 1664 type = refType->getPointeeType(); 1665 cvr = 0; // qualifiers don't recursively apply to referencee 1666 } 1667 } 1668 1669 unsigned alignment = getContext().getDeclAlign(field).getQuantity(); 1670 LValue LV = MakeAddrLValue(addr, type, alignment); 1671 LV.getQuals().addCVRQualifiers(cvr); 1672 1673 // __weak attribute on a field is ignored. 1674 if (LV.getQuals().getObjCGCAttr() == Qualifiers::Weak) 1675 LV.getQuals().removeObjCGCAttr(); 1676 1677 // Fields of may_alias structs act like 'char' for TBAA purposes. 1678 // FIXME: this should get propagated down through anonymous structs 1679 // and unions. 1680 if (mayAlias && LV.getTBAAInfo()) 1681 LV.setTBAAInfo(CGM.getTBAAInfo(getContext().CharTy)); 1682 1683 return LV; 1684} 1685 1686LValue 1687CodeGenFunction::EmitLValueForFieldInitialization(llvm::Value *BaseValue, 1688 const FieldDecl *Field, 1689 unsigned CVRQualifiers) { 1690 QualType FieldType = Field->getType(); 1691 1692 if (!FieldType->isReferenceType()) 1693 return EmitLValueForField(BaseValue, Field, CVRQualifiers); 1694 1695 const CGRecordLayout &RL = 1696 CGM.getTypes().getCGRecordLayout(Field->getParent()); 1697 unsigned idx = RL.getLLVMFieldNo(Field); 1698 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp"); 1699 1700 assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs"); 1701 1702 unsigned Alignment = getContext().getDeclAlign(Field).getQuantity(); 1703 return MakeAddrLValue(V, FieldType, Alignment); 1704} 1705 1706LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr *E){ 1707 llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral"); 1708 const Expr *InitExpr = E->getInitializer(); 1709 LValue Result = MakeAddrLValue(DeclPtr, E->getType()); 1710 1711 EmitAnyExprToMem(InitExpr, DeclPtr, /*Volatile*/ false, /*Init*/ true); 1712 1713 return Result; 1714} 1715 1716LValue CodeGenFunction:: 1717EmitConditionalOperatorLValue(const AbstractConditionalOperator *expr) { 1718 if (!expr->isGLValue()) { 1719 // ?: here should be an aggregate. 1720 assert((hasAggregateLLVMType(expr->getType()) && 1721 !expr->getType()->isAnyComplexType()) && 1722 "Unexpected conditional operator!"); 1723 return EmitAggExprToLValue(expr); 1724 } 1725 1726 const Expr *condExpr = expr->getCond(); 1727 bool CondExprBool; 1728 if (ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) { 1729 const Expr *live = expr->getTrueExpr(), *dead = expr->getFalseExpr(); 1730 if (!CondExprBool) std::swap(live, dead); 1731 1732 if (!ContainsLabel(dead)) 1733 return EmitLValue(live); 1734 } 1735 1736 OpaqueValueMapping binding(*this, expr); 1737 1738 llvm::BasicBlock *lhsBlock = createBasicBlock("cond.true"); 1739 llvm::BasicBlock *rhsBlock = createBasicBlock("cond.false"); 1740 llvm::BasicBlock *contBlock = createBasicBlock("cond.end"); 1741 1742 ConditionalEvaluation eval(*this); 1743 EmitBranchOnBoolExpr(condExpr, lhsBlock, rhsBlock); 1744 1745 // Any temporaries created here are conditional. 1746 EmitBlock(lhsBlock); 1747 eval.begin(*this); 1748 LValue lhs = EmitLValue(expr->getTrueExpr()); 1749 eval.end(*this); 1750 1751 if (!lhs.isSimple()) 1752 return EmitUnsupportedLValue(expr, "conditional operator"); 1753 1754 lhsBlock = Builder.GetInsertBlock(); 1755 Builder.CreateBr(contBlock); 1756 1757 // Any temporaries created here are conditional. 1758 EmitBlock(rhsBlock); 1759 eval.begin(*this); 1760 LValue rhs = EmitLValue(expr->getFalseExpr()); 1761 eval.end(*this); 1762 if (!rhs.isSimple()) 1763 return EmitUnsupportedLValue(expr, "conditional operator"); 1764 rhsBlock = Builder.GetInsertBlock(); 1765 1766 EmitBlock(contBlock); 1767 1768 llvm::PHINode *phi = Builder.CreatePHI(lhs.getAddress()->getType(), 2, 1769 "cond-lvalue"); 1770 phi->addIncoming(lhs.getAddress(), lhsBlock); 1771 phi->addIncoming(rhs.getAddress(), rhsBlock); 1772 return MakeAddrLValue(phi, expr->getType()); 1773} 1774 1775/// EmitCastLValue - Casts are never lvalues unless that cast is a dynamic_cast. 1776/// If the cast is a dynamic_cast, we can have the usual lvalue result, 1777/// otherwise if a cast is needed by the code generator in an lvalue context, 1778/// then it must mean that we need the address of an aggregate in order to 1779/// access one of its fields. This can happen for all the reasons that casts 1780/// are permitted with aggregate result, including noop aggregate casts, and 1781/// cast from scalar to union. 1782LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { 1783 switch (E->getCastKind()) { 1784 case CK_ToVoid: 1785 return EmitUnsupportedLValue(E, "unexpected cast lvalue"); 1786 1787 case CK_Dependent: 1788 llvm_unreachable("dependent cast kind in IR gen!"); 1789 1790 case CK_GetObjCProperty: { 1791 LValue LV = EmitLValue(E->getSubExpr()); 1792 assert(LV.isPropertyRef()); 1793 RValue RV = EmitLoadOfPropertyRefLValue(LV); 1794 1795 // Property is an aggregate r-value. 1796 if (RV.isAggregate()) { 1797 return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 1798 } 1799 1800 // Implicit property returns an l-value. 1801 assert(RV.isScalar()); 1802 return MakeAddrLValue(RV.getScalarVal(), E->getSubExpr()->getType()); 1803 } 1804 1805 case CK_NoOp: 1806 case CK_LValueToRValue: 1807 if (!E->getSubExpr()->Classify(getContext()).isPRValue() 1808 || E->getType()->isRecordType()) 1809 return EmitLValue(E->getSubExpr()); 1810 // Fall through to synthesize a temporary. 1811 1812 case CK_BitCast: 1813 case CK_ArrayToPointerDecay: 1814 case CK_FunctionToPointerDecay: 1815 case CK_NullToMemberPointer: 1816 case CK_NullToPointer: 1817 case CK_IntegralToPointer: 1818 case CK_PointerToIntegral: 1819 case CK_PointerToBoolean: 1820 case CK_VectorSplat: 1821 case CK_IntegralCast: 1822 case CK_IntegralToBoolean: 1823 case CK_IntegralToFloating: 1824 case CK_FloatingToIntegral: 1825 case CK_FloatingToBoolean: 1826 case CK_FloatingCast: 1827 case CK_FloatingRealToComplex: 1828 case CK_FloatingComplexToReal: 1829 case CK_FloatingComplexToBoolean: 1830 case CK_FloatingComplexCast: 1831 case CK_FloatingComplexToIntegralComplex: 1832 case CK_IntegralRealToComplex: 1833 case CK_IntegralComplexToReal: 1834 case CK_IntegralComplexToBoolean: 1835 case CK_IntegralComplexCast: 1836 case CK_IntegralComplexToFloatingComplex: 1837 case CK_DerivedToBaseMemberPointer: 1838 case CK_BaseToDerivedMemberPointer: 1839 case CK_MemberPointerToBoolean: 1840 case CK_AnyPointerToBlockPointerCast: { 1841 // These casts only produce lvalues when we're binding a reference to a 1842 // temporary realized from a (converted) pure rvalue. Emit the expression 1843 // as a value, copy it into a temporary, and return an lvalue referring to 1844 // that temporary. 1845 llvm::Value *V = CreateMemTemp(E->getType(), "ref.temp"); 1846 EmitAnyExprToMem(E, V, false, false); 1847 return MakeAddrLValue(V, E->getType()); 1848 } 1849 1850 case CK_Dynamic: { 1851 LValue LV = EmitLValue(E->getSubExpr()); 1852 llvm::Value *V = LV.getAddress(); 1853 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E); 1854 return MakeAddrLValue(EmitDynamicCast(V, DCE), E->getType()); 1855 } 1856 1857 case CK_ConstructorConversion: 1858 case CK_UserDefinedConversion: 1859 case CK_AnyPointerToObjCPointerCast: 1860 return EmitLValue(E->getSubExpr()); 1861 1862 case CK_UncheckedDerivedToBase: 1863 case CK_DerivedToBase: { 1864 const RecordType *DerivedClassTy = 1865 E->getSubExpr()->getType()->getAs<RecordType>(); 1866 CXXRecordDecl *DerivedClassDecl = 1867 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1868 1869 LValue LV = EmitLValue(E->getSubExpr()); 1870 llvm::Value *This = LV.getAddress(); 1871 1872 // Perform the derived-to-base conversion 1873 llvm::Value *Base = 1874 GetAddressOfBaseClass(This, DerivedClassDecl, 1875 E->path_begin(), E->path_end(), 1876 /*NullCheckValue=*/false); 1877 1878 return MakeAddrLValue(Base, E->getType()); 1879 } 1880 case CK_ToUnion: 1881 return EmitAggExprToLValue(E); 1882 case CK_BaseToDerived: { 1883 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>(); 1884 CXXRecordDecl *DerivedClassDecl = 1885 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1886 1887 LValue LV = EmitLValue(E->getSubExpr()); 1888 1889 // Perform the base-to-derived conversion 1890 llvm::Value *Derived = 1891 GetAddressOfDerivedClass(LV.getAddress(), DerivedClassDecl, 1892 E->path_begin(), E->path_end(), 1893 /*NullCheckValue=*/false); 1894 1895 return MakeAddrLValue(Derived, E->getType()); 1896 } 1897 case CK_LValueBitCast: { 1898 // This must be a reinterpret_cast (or c-style equivalent). 1899 const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E); 1900 1901 LValue LV = EmitLValue(E->getSubExpr()); 1902 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(), 1903 ConvertType(CE->getTypeAsWritten())); 1904 return MakeAddrLValue(V, E->getType()); 1905 } 1906 case CK_ObjCObjectLValueCast: { 1907 LValue LV = EmitLValue(E->getSubExpr()); 1908 QualType ToType = getContext().getLValueReferenceType(E->getType()); 1909 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(), 1910 ConvertType(ToType)); 1911 return MakeAddrLValue(V, E->getType()); 1912 } 1913 } 1914 1915 llvm_unreachable("Unhandled lvalue cast kind?"); 1916} 1917 1918LValue CodeGenFunction::EmitNullInitializationLValue( 1919 const CXXScalarValueInitExpr *E) { 1920 QualType Ty = E->getType(); 1921 LValue LV = MakeAddrLValue(CreateMemTemp(Ty), Ty); 1922 EmitNullInitialization(LV.getAddress(), Ty); 1923 return LV; 1924} 1925 1926LValue CodeGenFunction::EmitOpaqueValueLValue(const OpaqueValueExpr *e) { 1927 assert(e->isGLValue() || e->getType()->isRecordType()); 1928 return getOpaqueLValueMapping(e); 1929} 1930 1931//===--------------------------------------------------------------------===// 1932// Expression Emission 1933//===--------------------------------------------------------------------===// 1934 1935 1936RValue CodeGenFunction::EmitCallExpr(const CallExpr *E, 1937 ReturnValueSlot ReturnValue) { 1938 if (CGDebugInfo *DI = getDebugInfo()) { 1939 DI->setLocation(E->getLocStart()); 1940 DI->UpdateLineDirectiveRegion(Builder); 1941 DI->EmitStopPoint(Builder); 1942 } 1943 1944 // Builtins never have block type. 1945 if (E->getCallee()->getType()->isBlockPointerType()) 1946 return EmitBlockCallExpr(E, ReturnValue); 1947 1948 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E)) 1949 return EmitCXXMemberCallExpr(CE, ReturnValue); 1950 1951 const Decl *TargetDecl = 0; 1952 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) { 1953 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) { 1954 TargetDecl = DRE->getDecl(); 1955 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl)) 1956 if (unsigned builtinID = FD->getBuiltinID()) 1957 return EmitBuiltinExpr(FD, builtinID, E); 1958 } 1959 } 1960 1961 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E)) 1962 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl)) 1963 return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue); 1964 1965 if (isa<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) { 1966 // C++ [expr.pseudo]p1: 1967 // The result shall only be used as the operand for the function call 1968 // operator (), and the result of such a call has type void. The only 1969 // effect is the evaluation of the postfix-expression before the dot or 1970 // arrow. 1971 EmitScalarExpr(E->getCallee()); 1972 return RValue::get(0); 1973 } 1974 1975 llvm::Value *Callee = EmitScalarExpr(E->getCallee()); 1976 return EmitCall(E->getCallee()->getType(), Callee, ReturnValue, 1977 E->arg_begin(), E->arg_end(), TargetDecl); 1978} 1979 1980LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) { 1981 // Comma expressions just emit their LHS then their RHS as an l-value. 1982 if (E->getOpcode() == BO_Comma) { 1983 EmitIgnoredExpr(E->getLHS()); 1984 EnsureInsertPoint(); 1985 return EmitLValue(E->getRHS()); 1986 } 1987 1988 if (E->getOpcode() == BO_PtrMemD || 1989 E->getOpcode() == BO_PtrMemI) 1990 return EmitPointerToDataMemberBinaryExpr(E); 1991 1992 assert(E->getOpcode() == BO_Assign && "unexpected binary l-value"); 1993 1994 if (!hasAggregateLLVMType(E->getType())) { 1995 // __block variables need the RHS evaluated first. 1996 RValue RV = EmitAnyExpr(E->getRHS()); 1997 LValue LV = EmitLValue(E->getLHS()); 1998 EmitStoreThroughLValue(RV, LV, E->getType()); 1999 return LV; 2000 } 2001 2002 if (E->getType()->isAnyComplexType()) 2003 return EmitComplexAssignmentLValue(E); 2004 2005 return EmitAggExprToLValue(E); 2006} 2007 2008LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) { 2009 RValue RV = EmitCallExpr(E); 2010 2011 if (!RV.isScalar()) 2012 return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 2013 2014 assert(E->getCallReturnType()->isReferenceType() && 2015 "Can't have a scalar return unless the return type is a " 2016 "reference type!"); 2017 2018 return MakeAddrLValue(RV.getScalarVal(), E->getType()); 2019} 2020 2021LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) { 2022 // FIXME: This shouldn't require another copy. 2023 return EmitAggExprToLValue(E); 2024} 2025 2026LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) { 2027 assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor() 2028 && "binding l-value to type which needs a temporary"); 2029 AggValueSlot Slot = CreateAggTemp(E->getType(), "tmp"); 2030 EmitCXXConstructExpr(E, Slot); 2031 return MakeAddrLValue(Slot.getAddr(), E->getType()); 2032} 2033 2034LValue 2035CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) { 2036 return MakeAddrLValue(EmitCXXTypeidExpr(E), E->getType()); 2037} 2038 2039LValue 2040CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) { 2041 AggValueSlot Slot = CreateAggTemp(E->getType(), "temp.lvalue"); 2042 Slot.setLifetimeExternallyManaged(); 2043 EmitAggExpr(E->getSubExpr(), Slot); 2044 EmitCXXTemporary(E->getTemporary(), Slot.getAddr()); 2045 return MakeAddrLValue(Slot.getAddr(), E->getType()); 2046} 2047 2048LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) { 2049 RValue RV = EmitObjCMessageExpr(E); 2050 2051 if (!RV.isScalar()) 2052 return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 2053 2054 assert(E->getMethodDecl()->getResultType()->isReferenceType() && 2055 "Can't have a scalar return unless the return type is a " 2056 "reference type!"); 2057 2058 return MakeAddrLValue(RV.getScalarVal(), E->getType()); 2059} 2060 2061LValue CodeGenFunction::EmitObjCSelectorLValue(const ObjCSelectorExpr *E) { 2062 llvm::Value *V = 2063 CGM.getObjCRuntime().GetSelector(Builder, E->getSelector(), true); 2064 return MakeAddrLValue(V, E->getType()); 2065} 2066 2067llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface, 2068 const ObjCIvarDecl *Ivar) { 2069 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar); 2070} 2071 2072LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy, 2073 llvm::Value *BaseValue, 2074 const ObjCIvarDecl *Ivar, 2075 unsigned CVRQualifiers) { 2076 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue, 2077 Ivar, CVRQualifiers); 2078} 2079 2080LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) { 2081 // FIXME: A lot of the code below could be shared with EmitMemberExpr. 2082 llvm::Value *BaseValue = 0; 2083 const Expr *BaseExpr = E->getBase(); 2084 Qualifiers BaseQuals; 2085 QualType ObjectTy; 2086 if (E->isArrow()) { 2087 BaseValue = EmitScalarExpr(BaseExpr); 2088 ObjectTy = BaseExpr->getType()->getPointeeType(); 2089 BaseQuals = ObjectTy.getQualifiers(); 2090 } else { 2091 LValue BaseLV = EmitLValue(BaseExpr); 2092 // FIXME: this isn't right for bitfields. 2093 BaseValue = BaseLV.getAddress(); 2094 ObjectTy = BaseExpr->getType(); 2095 BaseQuals = ObjectTy.getQualifiers(); 2096 } 2097 2098 LValue LV = 2099 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(), 2100 BaseQuals.getCVRQualifiers()); 2101 setObjCGCLValueClass(getContext(), E, LV); 2102 return LV; 2103} 2104 2105LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) { 2106 // Can only get l-value for message expression returning aggregate type 2107 RValue RV = EmitAnyExprToTemp(E); 2108 return MakeAddrLValue(RV.getAggregateAddr(), E->getType()); 2109} 2110 2111RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee, 2112 ReturnValueSlot ReturnValue, 2113 CallExpr::const_arg_iterator ArgBeg, 2114 CallExpr::const_arg_iterator ArgEnd, 2115 const Decl *TargetDecl) { 2116 // Get the actual function type. The callee type will always be a pointer to 2117 // function type or a block pointer type. 2118 assert(CalleeType->isFunctionPointerType() && 2119 "Call must have function pointer type!"); 2120 2121 CalleeType = getContext().getCanonicalType(CalleeType); 2122 2123 const FunctionType *FnType 2124 = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType()); 2125 2126 CallArgList Args; 2127 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd); 2128 2129 return EmitCall(CGM.getTypes().getFunctionInfo(Args, FnType), 2130 Callee, ReturnValue, Args, TargetDecl); 2131} 2132 2133LValue CodeGenFunction:: 2134EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) { 2135 llvm::Value *BaseV; 2136 if (E->getOpcode() == BO_PtrMemI) 2137 BaseV = EmitScalarExpr(E->getLHS()); 2138 else 2139 BaseV = EmitLValue(E->getLHS()).getAddress(); 2140 2141 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS()); 2142 2143 const MemberPointerType *MPT 2144 = E->getRHS()->getType()->getAs<MemberPointerType>(); 2145 2146 llvm::Value *AddV = 2147 CGM.getCXXABI().EmitMemberDataPointerAddress(*this, BaseV, OffsetV, MPT); 2148 2149 return MakeAddrLValue(AddV, MPT->getPointeeType()); 2150} 2151