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