CGExpr.cpp revision 1e74c4f0333b4730f44197d5e4615ea2b06599f4
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 "CGObjCRuntime.h" 18#include "clang/AST/ASTContext.h" 19#include "clang/AST/DeclObjC.h" 20#include "llvm/Target/TargetData.h" 21using namespace clang; 22using namespace CodeGen; 23 24//===--------------------------------------------------------------------===// 25// Miscellaneous Helper Methods 26//===--------------------------------------------------------------------===// 27 28/// CreateTempAlloca - This creates a alloca and inserts it into the entry 29/// block. 30llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(const llvm::Type *Ty, 31 const llvm::Twine &Name) { 32 if (!Builder.isNamePreserving()) 33 return new llvm::AllocaInst(Ty, 0, "", AllocaInsertPt); 34 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt); 35} 36 37/// EvaluateExprAsBool - Perform the usual unary conversions on the specified 38/// expression and compare the result against zero, returning an Int1Ty value. 39llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) { 40 QualType BoolTy = getContext().BoolTy; 41 if (!E->getType()->isAnyComplexType()) 42 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy); 43 44 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy); 45} 46 47/// EmitAnyExpr - Emit code to compute the specified expression which can have 48/// any type. The result is returned as an RValue struct. If this is an 49/// aggregate expression, the aggloc/agglocvolatile arguments indicate where the 50/// result should be returned. 51RValue CodeGenFunction::EmitAnyExpr(const Expr *E, llvm::Value *AggLoc, 52 bool IsAggLocVolatile, bool IgnoreResult, 53 bool IsInitializer) { 54 if (!hasAggregateLLVMType(E->getType())) 55 return RValue::get(EmitScalarExpr(E, IgnoreResult)); 56 else if (E->getType()->isAnyComplexType()) 57 return RValue::getComplex(EmitComplexExpr(E, false, false, 58 IgnoreResult, IgnoreResult)); 59 60 EmitAggExpr(E, AggLoc, IsAggLocVolatile, IgnoreResult, IsInitializer); 61 return RValue::getAggregate(AggLoc, IsAggLocVolatile); 62} 63 64/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result will 65/// always be accessible even if no aggregate location is provided. 66RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E, 67 bool IsAggLocVolatile, 68 bool IsInitializer) { 69 llvm::Value *AggLoc = 0; 70 71 if (hasAggregateLLVMType(E->getType()) && 72 !E->getType()->isAnyComplexType()) 73 AggLoc = CreateTempAlloca(ConvertType(E->getType()), "agg.tmp"); 74 return EmitAnyExpr(E, AggLoc, IsAggLocVolatile, /*IgnoreResult=*/false, 75 IsInitializer); 76} 77 78RValue CodeGenFunction::EmitReferenceBindingToExpr(const Expr* E, 79 QualType DestType, 80 bool IsInitializer) { 81 bool ShouldDestroyTemporaries = false; 82 unsigned OldNumLiveTemporaries = 0; 83 84 if (const CXXExprWithTemporaries *TE = dyn_cast<CXXExprWithTemporaries>(E)) { 85 ShouldDestroyTemporaries = TE->shouldDestroyTemporaries(); 86 87 // Keep track of the current cleanup stack depth. 88 if (ShouldDestroyTemporaries) 89 OldNumLiveTemporaries = LiveTemporaries.size(); 90 91 E = TE->getSubExpr(); 92 } 93 94 RValue Val; 95 if (E->isLvalue(getContext()) == Expr::LV_Valid) { 96 // Emit the expr as an lvalue. 97 LValue LV = EmitLValue(E); 98 if (LV.isSimple()) 99 return RValue::get(LV.getAddress()); 100 Val = EmitLoadOfLValue(LV, E->getType()); 101 102 if (ShouldDestroyTemporaries) { 103 // Pop temporaries. 104 while (LiveTemporaries.size() > OldNumLiveTemporaries) 105 PopCXXTemporary(); 106 } 107 } else { 108 const CXXRecordDecl *BaseClassDecl = 0; 109 const CXXRecordDecl *DerivedClassDecl = 0; 110 111 if (const CastExpr *CE = 112 dyn_cast<CastExpr>(E->IgnoreParenNoopCasts(getContext()))) { 113 if (CE->getCastKind() == CastExpr::CK_DerivedToBase) { 114 E = CE->getSubExpr(); 115 116 BaseClassDecl = 117 cast<CXXRecordDecl>(CE->getType()->getAs<RecordType>()->getDecl()); 118 DerivedClassDecl = 119 cast<CXXRecordDecl>(E->getType()->getAs<RecordType>()->getDecl()); 120 } 121 } 122 123 Val = EmitAnyExprToTemp(E, /*IsAggLocVolatile=*/false, 124 IsInitializer); 125 126 if (ShouldDestroyTemporaries) { 127 // Pop temporaries. 128 while (LiveTemporaries.size() > OldNumLiveTemporaries) 129 PopCXXTemporary(); 130 } 131 132 if (IsInitializer) { 133 // We might have to destroy the temporary variable. 134 if (const RecordType *RT = E->getType()->getAs<RecordType>()) { 135 if (CXXRecordDecl *ClassDecl = dyn_cast<CXXRecordDecl>(RT->getDecl())) { 136 if (!ClassDecl->hasTrivialDestructor()) { 137 const CXXDestructorDecl *Dtor = 138 ClassDecl->getDestructor(getContext()); 139 140 CleanupScope scope(*this); 141 EmitCXXDestructorCall(Dtor, Dtor_Complete, Val.getAggregateAddr()); 142 } 143 } 144 } 145 } 146 147 // Check if need to perform the derived-to-base cast. 148 if (BaseClassDecl) { 149 llvm::Value *Derived = Val.getAggregateAddr(); 150 llvm::Value *Base = 151 GetAddressCXXOfBaseClass(Derived, DerivedClassDecl, BaseClassDecl, 152 /*NullCheckValue=*/false); 153 return RValue::get(Base); 154 } 155 } 156 157 if (Val.isAggregate()) { 158 Val = RValue::get(Val.getAggregateAddr()); 159 } else { 160 // Create a temporary variable that we can bind the reference to. 161 llvm::Value *Temp = CreateTempAlloca(ConvertTypeForMem(E->getType()), 162 "reftmp"); 163 if (Val.isScalar()) 164 EmitStoreOfScalar(Val.getScalarVal(), Temp, false, E->getType()); 165 else 166 StoreComplexToAddr(Val.getComplexVal(), Temp, false); 167 Val = RValue::get(Temp); 168 } 169 170 return Val; 171} 172 173 174/// getAccessedFieldNo - Given an encoded value and a result number, return the 175/// input field number being accessed. 176unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx, 177 const llvm::Constant *Elts) { 178 if (isa<llvm::ConstantAggregateZero>(Elts)) 179 return 0; 180 181 return cast<llvm::ConstantInt>(Elts->getOperand(Idx))->getZExtValue(); 182} 183 184 185//===----------------------------------------------------------------------===// 186// LValue Expression Emission 187//===----------------------------------------------------------------------===// 188 189RValue CodeGenFunction::GetUndefRValue(QualType Ty) { 190 if (Ty->isVoidType()) 191 return RValue::get(0); 192 193 if (const ComplexType *CTy = Ty->getAs<ComplexType>()) { 194 const llvm::Type *EltTy = ConvertType(CTy->getElementType()); 195 llvm::Value *U = llvm::UndefValue::get(EltTy); 196 return RValue::getComplex(std::make_pair(U, U)); 197 } 198 199 if (hasAggregateLLVMType(Ty)) { 200 const llvm::Type *LTy = llvm::PointerType::getUnqual(ConvertType(Ty)); 201 return RValue::getAggregate(llvm::UndefValue::get(LTy)); 202 } 203 204 return RValue::get(llvm::UndefValue::get(ConvertType(Ty))); 205} 206 207RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E, 208 const char *Name) { 209 ErrorUnsupported(E, Name); 210 return GetUndefRValue(E->getType()); 211} 212 213LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E, 214 const char *Name) { 215 ErrorUnsupported(E, Name); 216 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 217 return LValue::MakeAddr(llvm::UndefValue::get(Ty), 218 MakeQualifiers(E->getType())); 219} 220 221/// EmitLValue - Emit code to compute a designator that specifies the location 222/// of the expression. 223/// 224/// This can return one of two things: a simple address or a bitfield reference. 225/// In either case, the LLVM Value* in the LValue structure is guaranteed to be 226/// an LLVM pointer type. 227/// 228/// If this returns a bitfield reference, nothing about the pointee type of the 229/// LLVM value is known: For example, it may not be a pointer to an integer. 230/// 231/// If this returns a normal address, and if the lvalue's C type is fixed size, 232/// this method guarantees that the returned pointer type will point to an LLVM 233/// type of the same size of the lvalue's type. If the lvalue has a variable 234/// length type, this is not possible. 235/// 236LValue CodeGenFunction::EmitLValue(const Expr *E) { 237 switch (E->getStmtClass()) { 238 default: return EmitUnsupportedLValue(E, "l-value expression"); 239 240 case Expr::BinaryOperatorClass: 241 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E)); 242 case Expr::CallExprClass: 243 case Expr::CXXMemberCallExprClass: 244 case Expr::CXXOperatorCallExprClass: 245 return EmitCallExprLValue(cast<CallExpr>(E)); 246 case Expr::VAArgExprClass: 247 return EmitVAArgExprLValue(cast<VAArgExpr>(E)); 248 case Expr::DeclRefExprClass: 249 return EmitDeclRefLValue(cast<DeclRefExpr>(E)); 250 case Expr::ParenExprClass:return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 251 case Expr::PredefinedExprClass: 252 return EmitPredefinedLValue(cast<PredefinedExpr>(E)); 253 case Expr::StringLiteralClass: 254 return EmitStringLiteralLValue(cast<StringLiteral>(E)); 255 case Expr::ObjCEncodeExprClass: 256 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E)); 257 258 case Expr::BlockDeclRefExprClass: 259 return EmitBlockDeclRefLValue(cast<BlockDeclRefExpr>(E)); 260 261 case Expr::CXXConditionDeclExprClass: 262 return EmitCXXConditionDeclLValue(cast<CXXConditionDeclExpr>(E)); 263 case Expr::CXXTemporaryObjectExprClass: 264 case Expr::CXXConstructExprClass: 265 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E)); 266 case Expr::CXXBindTemporaryExprClass: 267 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E)); 268 case Expr::CXXExprWithTemporariesClass: 269 return EmitCXXExprWithTemporariesLValue(cast<CXXExprWithTemporaries>(E)); 270 271 case Expr::ObjCMessageExprClass: 272 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E)); 273 case Expr::ObjCIvarRefExprClass: 274 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E)); 275 case Expr::ObjCPropertyRefExprClass: 276 return EmitObjCPropertyRefLValue(cast<ObjCPropertyRefExpr>(E)); 277 case Expr::ObjCImplicitSetterGetterRefExprClass: 278 return EmitObjCKVCRefLValue(cast<ObjCImplicitSetterGetterRefExpr>(E)); 279 case Expr::ObjCSuperExprClass: 280 return EmitObjCSuperExprLValue(cast<ObjCSuperExpr>(E)); 281 282 case Expr::StmtExprClass: 283 return EmitStmtExprLValue(cast<StmtExpr>(E)); 284 case Expr::UnaryOperatorClass: 285 return EmitUnaryOpLValue(cast<UnaryOperator>(E)); 286 case Expr::ArraySubscriptExprClass: 287 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E)); 288 case Expr::ExtVectorElementExprClass: 289 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E)); 290 case Expr::MemberExprClass: 291 return EmitMemberExpr(cast<MemberExpr>(E)); 292 case Expr::CompoundLiteralExprClass: 293 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E)); 294 case Expr::ConditionalOperatorClass: 295 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E)); 296 case Expr::ChooseExprClass: 297 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext())); 298 case Expr::ImplicitCastExprClass: 299 case Expr::CStyleCastExprClass: 300 case Expr::CXXFunctionalCastExprClass: 301 case Expr::CXXStaticCastExprClass: 302 case Expr::CXXDynamicCastExprClass: 303 case Expr::CXXReinterpretCastExprClass: 304 case Expr::CXXConstCastExprClass: 305 return EmitCastLValue(cast<CastExpr>(E)); 306 case Expr::CXXZeroInitValueExprClass: 307 return EmitNullInitializationLValue(cast<CXXZeroInitValueExpr>(E)); 308 } 309} 310 311llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile, 312 QualType Ty) { 313 llvm::Value *V = Builder.CreateLoad(Addr, Volatile, "tmp"); 314 315 // Bool can have different representation in memory than in registers. 316 if (Ty->isBooleanType()) 317 if (V->getType() != llvm::Type::getInt1Ty(VMContext)) 318 V = Builder.CreateTrunc(V, llvm::Type::getInt1Ty(VMContext), "tobool"); 319 320 return V; 321} 322 323void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr, 324 bool Volatile, QualType Ty) { 325 326 if (Ty->isBooleanType()) { 327 // Bool can have different representation in memory than in registers. 328 const llvm::Type *SrcTy = Value->getType(); 329 const llvm::PointerType *DstPtr = cast<llvm::PointerType>(Addr->getType()); 330 if (DstPtr->getElementType() != SrcTy) { 331 const llvm::Type *MemTy = 332 llvm::PointerType::get(SrcTy, DstPtr->getAddressSpace()); 333 Addr = Builder.CreateBitCast(Addr, MemTy, "storetmp"); 334 } 335 } 336 Builder.CreateStore(Value, Addr, Volatile); 337} 338 339/// EmitLoadOfLValue - Given an expression that represents a value lvalue, this 340/// method emits the address of the lvalue, then loads the result as an rvalue, 341/// returning the rvalue. 342RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, QualType ExprType) { 343 if (LV.isObjCWeak()) { 344 // load of a __weak object. 345 llvm::Value *AddrWeakObj = LV.getAddress(); 346 return RValue::get(CGM.getObjCRuntime().EmitObjCWeakRead(*this, 347 AddrWeakObj)); 348 } 349 350 if (LV.isSimple()) { 351 llvm::Value *Ptr = LV.getAddress(); 352 const llvm::Type *EltTy = 353 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 354 355 // Simple scalar l-value. 356 if (EltTy->isSingleValueType()) 357 return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(), 358 ExprType)); 359 360 assert(ExprType->isFunctionType() && "Unknown scalar value"); 361 return RValue::get(Ptr); 362 } 363 364 if (LV.isVectorElt()) { 365 llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(), 366 LV.isVolatileQualified(), "tmp"); 367 return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(), 368 "vecext")); 369 } 370 371 // If this is a reference to a subset of the elements of a vector, either 372 // shuffle the input or extract/insert them as appropriate. 373 if (LV.isExtVectorElt()) 374 return EmitLoadOfExtVectorElementLValue(LV, ExprType); 375 376 if (LV.isBitfield()) 377 return EmitLoadOfBitfieldLValue(LV, ExprType); 378 379 if (LV.isPropertyRef()) 380 return EmitLoadOfPropertyRefLValue(LV, ExprType); 381 382 assert(LV.isKVCRef() && "Unknown LValue type!"); 383 return EmitLoadOfKVCRefLValue(LV, ExprType); 384} 385 386RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV, 387 QualType ExprType) { 388 unsigned StartBit = LV.getBitfieldStartBit(); 389 unsigned BitfieldSize = LV.getBitfieldSize(); 390 llvm::Value *Ptr = LV.getBitfieldAddr(); 391 392 const llvm::Type *EltTy = 393 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 394 unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy); 395 396 // In some cases the bitfield may straddle two memory locations. Currently we 397 // load the entire bitfield, then do the magic to sign-extend it if 398 // necessary. This results in somewhat more code than necessary for the common 399 // case (one load), since two shifts accomplish both the masking and sign 400 // extension. 401 unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit); 402 llvm::Value *Val = Builder.CreateLoad(Ptr, LV.isVolatileQualified(), "tmp"); 403 404 // Shift to proper location. 405 if (StartBit) 406 Val = Builder.CreateLShr(Val, llvm::ConstantInt::get(EltTy, StartBit), 407 "bf.lo"); 408 409 // Mask off unused bits. 410 llvm::Constant *LowMask = llvm::ConstantInt::get(VMContext, 411 llvm::APInt::getLowBitsSet(EltTySize, LowBits)); 412 Val = Builder.CreateAnd(Val, LowMask, "bf.lo.cleared"); 413 414 // Fetch the high bits if necessary. 415 if (LowBits < BitfieldSize) { 416 unsigned HighBits = BitfieldSize - LowBits; 417 llvm::Value *HighPtr = Builder.CreateGEP(Ptr, llvm::ConstantInt::get( 418 llvm::Type::getInt32Ty(VMContext), 1), "bf.ptr.hi"); 419 llvm::Value *HighVal = Builder.CreateLoad(HighPtr, 420 LV.isVolatileQualified(), 421 "tmp"); 422 423 // Mask off unused bits. 424 llvm::Constant *HighMask = llvm::ConstantInt::get(VMContext, 425 llvm::APInt::getLowBitsSet(EltTySize, HighBits)); 426 HighVal = Builder.CreateAnd(HighVal, HighMask, "bf.lo.cleared"); 427 428 // Shift to proper location and or in to bitfield value. 429 HighVal = Builder.CreateShl(HighVal, 430 llvm::ConstantInt::get(EltTy, LowBits)); 431 Val = Builder.CreateOr(Val, HighVal, "bf.val"); 432 } 433 434 // Sign extend if necessary. 435 if (LV.isBitfieldSigned()) { 436 llvm::Value *ExtraBits = llvm::ConstantInt::get(EltTy, 437 EltTySize - BitfieldSize); 438 Val = Builder.CreateAShr(Builder.CreateShl(Val, ExtraBits), 439 ExtraBits, "bf.val.sext"); 440 } 441 442 // The bitfield type and the normal type differ when the storage sizes differ 443 // (currently just _Bool). 444 Val = Builder.CreateIntCast(Val, ConvertType(ExprType), false, "tmp"); 445 446 return RValue::get(Val); 447} 448 449RValue CodeGenFunction::EmitLoadOfPropertyRefLValue(LValue LV, 450 QualType ExprType) { 451 return EmitObjCPropertyGet(LV.getPropertyRefExpr()); 452} 453 454RValue CodeGenFunction::EmitLoadOfKVCRefLValue(LValue LV, 455 QualType ExprType) { 456 return EmitObjCPropertyGet(LV.getKVCRefExpr()); 457} 458 459// If this is a reference to a subset of the elements of a vector, create an 460// appropriate shufflevector. 461RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV, 462 QualType ExprType) { 463 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(), 464 LV.isVolatileQualified(), "tmp"); 465 466 const llvm::Constant *Elts = LV.getExtVectorElts(); 467 468 // If the result of the expression is a non-vector type, we must be extracting 469 // a single element. Just codegen as an extractelement. 470 const VectorType *ExprVT = ExprType->getAs<VectorType>(); 471 if (!ExprVT) { 472 unsigned InIdx = getAccessedFieldNo(0, Elts); 473 llvm::Value *Elt = llvm::ConstantInt::get( 474 llvm::Type::getInt32Ty(VMContext), InIdx); 475 return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp")); 476 } 477 478 // Always use shuffle vector to try to retain the original program structure 479 unsigned NumResultElts = ExprVT->getNumElements(); 480 481 llvm::SmallVector<llvm::Constant*, 4> Mask; 482 for (unsigned i = 0; i != NumResultElts; ++i) { 483 unsigned InIdx = getAccessedFieldNo(i, Elts); 484 Mask.push_back(llvm::ConstantInt::get( 485 llvm::Type::getInt32Ty(VMContext), InIdx)); 486 } 487 488 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 489 Vec = Builder.CreateShuffleVector(Vec, 490 llvm::UndefValue::get(Vec->getType()), 491 MaskV, "tmp"); 492 return RValue::get(Vec); 493} 494 495 496 497/// EmitStoreThroughLValue - Store the specified rvalue into the specified 498/// lvalue, where both are guaranteed to the have the same type, and that type 499/// is 'Ty'. 500void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, 501 QualType Ty) { 502 if (!Dst.isSimple()) { 503 if (Dst.isVectorElt()) { 504 // Read/modify/write the vector, inserting the new element. 505 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(), 506 Dst.isVolatileQualified(), "tmp"); 507 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), 508 Dst.getVectorIdx(), "vecins"); 509 Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified()); 510 return; 511 } 512 513 // If this is an update of extended vector elements, insert them as 514 // appropriate. 515 if (Dst.isExtVectorElt()) 516 return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty); 517 518 if (Dst.isBitfield()) 519 return EmitStoreThroughBitfieldLValue(Src, Dst, Ty); 520 521 if (Dst.isPropertyRef()) 522 return EmitStoreThroughPropertyRefLValue(Src, Dst, Ty); 523 524 assert(Dst.isKVCRef() && "Unknown LValue type"); 525 return EmitStoreThroughKVCRefLValue(Src, Dst, Ty); 526 } 527 528 if (Dst.isObjCWeak() && !Dst.isNonGC()) { 529 // load of a __weak object. 530 llvm::Value *LvalueDst = Dst.getAddress(); 531 llvm::Value *src = Src.getScalarVal(); 532 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst); 533 return; 534 } 535 536 if (Dst.isObjCStrong() && !Dst.isNonGC()) { 537 // load of a __strong object. 538 llvm::Value *LvalueDst = Dst.getAddress(); 539 llvm::Value *src = Src.getScalarVal(); 540 if (Dst.isObjCIvar()) { 541 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL"); 542 const llvm::Type *ResultType = ConvertType(getContext().LongTy); 543 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp()); 544 llvm::Value *dst = RHS; 545 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 546 llvm::Value *LHS = 547 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast"); 548 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset"); 549 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst, 550 BytesBetween); 551 } else if (Dst.isGlobalObjCRef()) 552 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst); 553 else 554 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst); 555 return; 556 } 557 558 assert(Src.isScalar() && "Can't emit an agg store with this method"); 559 EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(), 560 Dst.isVolatileQualified(), Ty); 561} 562 563void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 564 QualType Ty, 565 llvm::Value **Result) { 566 unsigned StartBit = Dst.getBitfieldStartBit(); 567 unsigned BitfieldSize = Dst.getBitfieldSize(); 568 llvm::Value *Ptr = Dst.getBitfieldAddr(); 569 570 const llvm::Type *EltTy = 571 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 572 unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy); 573 574 // Get the new value, cast to the appropriate type and masked to exactly the 575 // size of the bit-field. 576 llvm::Value *SrcVal = Src.getScalarVal(); 577 llvm::Value *NewVal = Builder.CreateIntCast(SrcVal, EltTy, false, "tmp"); 578 llvm::Constant *Mask = llvm::ConstantInt::get(VMContext, 579 llvm::APInt::getLowBitsSet(EltTySize, BitfieldSize)); 580 NewVal = Builder.CreateAnd(NewVal, Mask, "bf.value"); 581 582 // Return the new value of the bit-field, if requested. 583 if (Result) { 584 // Cast back to the proper type for result. 585 const llvm::Type *SrcTy = SrcVal->getType(); 586 llvm::Value *SrcTrunc = Builder.CreateIntCast(NewVal, SrcTy, false, 587 "bf.reload.val"); 588 589 // Sign extend if necessary. 590 if (Dst.isBitfieldSigned()) { 591 unsigned SrcTySize = CGM.getTargetData().getTypeSizeInBits(SrcTy); 592 llvm::Value *ExtraBits = llvm::ConstantInt::get(SrcTy, 593 SrcTySize - BitfieldSize); 594 SrcTrunc = Builder.CreateAShr(Builder.CreateShl(SrcTrunc, ExtraBits), 595 ExtraBits, "bf.reload.sext"); 596 } 597 598 *Result = SrcTrunc; 599 } 600 601 // In some cases the bitfield may straddle two memory locations. Emit the low 602 // part first and check to see if the high needs to be done. 603 unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit); 604 llvm::Value *LowVal = Builder.CreateLoad(Ptr, Dst.isVolatileQualified(), 605 "bf.prev.low"); 606 607 // Compute the mask for zero-ing the low part of this bitfield. 608 llvm::Constant *InvMask = 609 llvm::ConstantInt::get(VMContext, 610 ~llvm::APInt::getBitsSet(EltTySize, StartBit, StartBit + LowBits)); 611 612 // Compute the new low part as 613 // LowVal = (LowVal & InvMask) | (NewVal << StartBit), 614 // with the shift of NewVal implicitly stripping the high bits. 615 llvm::Value *NewLowVal = 616 Builder.CreateShl(NewVal, llvm::ConstantInt::get(EltTy, StartBit), 617 "bf.value.lo"); 618 LowVal = Builder.CreateAnd(LowVal, InvMask, "bf.prev.lo.cleared"); 619 LowVal = Builder.CreateOr(LowVal, NewLowVal, "bf.new.lo"); 620 621 // Write back. 622 Builder.CreateStore(LowVal, Ptr, Dst.isVolatileQualified()); 623 624 // If the low part doesn't cover the bitfield emit a high part. 625 if (LowBits < BitfieldSize) { 626 unsigned HighBits = BitfieldSize - LowBits; 627 llvm::Value *HighPtr = Builder.CreateGEP(Ptr, llvm::ConstantInt::get( 628 llvm::Type::getInt32Ty(VMContext), 1), "bf.ptr.hi"); 629 llvm::Value *HighVal = Builder.CreateLoad(HighPtr, 630 Dst.isVolatileQualified(), 631 "bf.prev.hi"); 632 633 // Compute the mask for zero-ing the high part of this bitfield. 634 llvm::Constant *InvMask = 635 llvm::ConstantInt::get(VMContext, ~llvm::APInt::getLowBitsSet(EltTySize, 636 HighBits)); 637 638 // Compute the new high part as 639 // HighVal = (HighVal & InvMask) | (NewVal lshr LowBits), 640 // where the high bits of NewVal have already been cleared and the 641 // shift stripping the low bits. 642 llvm::Value *NewHighVal = 643 Builder.CreateLShr(NewVal, llvm::ConstantInt::get(EltTy, LowBits), 644 "bf.value.high"); 645 HighVal = Builder.CreateAnd(HighVal, InvMask, "bf.prev.hi.cleared"); 646 HighVal = Builder.CreateOr(HighVal, NewHighVal, "bf.new.hi"); 647 648 // Write back. 649 Builder.CreateStore(HighVal, HighPtr, Dst.isVolatileQualified()); 650 } 651} 652 653void CodeGenFunction::EmitStoreThroughPropertyRefLValue(RValue Src, 654 LValue Dst, 655 QualType Ty) { 656 EmitObjCPropertySet(Dst.getPropertyRefExpr(), Src); 657} 658 659void CodeGenFunction::EmitStoreThroughKVCRefLValue(RValue Src, 660 LValue Dst, 661 QualType Ty) { 662 EmitObjCPropertySet(Dst.getKVCRefExpr(), Src); 663} 664 665void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, 666 LValue Dst, 667 QualType Ty) { 668 // This access turns into a read/modify/write of the vector. Load the input 669 // value now. 670 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(), 671 Dst.isVolatileQualified(), "tmp"); 672 const llvm::Constant *Elts = Dst.getExtVectorElts(); 673 674 llvm::Value *SrcVal = Src.getScalarVal(); 675 676 if (const VectorType *VTy = Ty->getAs<VectorType>()) { 677 unsigned NumSrcElts = VTy->getNumElements(); 678 unsigned NumDstElts = 679 cast<llvm::VectorType>(Vec->getType())->getNumElements(); 680 if (NumDstElts == NumSrcElts) { 681 // Use shuffle vector is the src and destination are the same number of 682 // elements and restore the vector mask since it is on the side it will be 683 // stored. 684 llvm::SmallVector<llvm::Constant*, 4> Mask(NumDstElts); 685 for (unsigned i = 0; i != NumSrcElts; ++i) { 686 unsigned InIdx = getAccessedFieldNo(i, Elts); 687 Mask[InIdx] = llvm::ConstantInt::get( 688 llvm::Type::getInt32Ty(VMContext), i); 689 } 690 691 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 692 Vec = Builder.CreateShuffleVector(SrcVal, 693 llvm::UndefValue::get(Vec->getType()), 694 MaskV, "tmp"); 695 } else if (NumDstElts > NumSrcElts) { 696 // Extended the source vector to the same length and then shuffle it 697 // into the destination. 698 // FIXME: since we're shuffling with undef, can we just use the indices 699 // into that? This could be simpler. 700 llvm::SmallVector<llvm::Constant*, 4> ExtMask; 701 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext); 702 unsigned i; 703 for (i = 0; i != NumSrcElts; ++i) 704 ExtMask.push_back(llvm::ConstantInt::get(Int32Ty, i)); 705 for (; i != NumDstElts; ++i) 706 ExtMask.push_back(llvm::UndefValue::get(Int32Ty)); 707 llvm::Value *ExtMaskV = llvm::ConstantVector::get(&ExtMask[0], 708 ExtMask.size()); 709 llvm::Value *ExtSrcVal = 710 Builder.CreateShuffleVector(SrcVal, 711 llvm::UndefValue::get(SrcVal->getType()), 712 ExtMaskV, "tmp"); 713 // build identity 714 llvm::SmallVector<llvm::Constant*, 4> Mask; 715 for (unsigned i = 0; i != NumDstElts; ++i) 716 Mask.push_back(llvm::ConstantInt::get(Int32Ty, i)); 717 718 // modify when what gets shuffled in 719 for (unsigned i = 0; i != NumSrcElts; ++i) { 720 unsigned Idx = getAccessedFieldNo(i, Elts); 721 Mask[Idx] = llvm::ConstantInt::get(Int32Ty, i+NumDstElts); 722 } 723 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 724 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp"); 725 } else { 726 // We should never shorten the vector 727 assert(0 && "unexpected shorten vector length"); 728 } 729 } else { 730 // If the Src is a scalar (not a vector) it must be updating one element. 731 unsigned InIdx = getAccessedFieldNo(0, Elts); 732 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext); 733 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx); 734 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp"); 735 } 736 737 Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified()); 738} 739 740// setObjCGCLValueClass - sets class of he lvalue for the purpose of 741// generating write-barries API. It is currently a global, ivar, 742// or neither. 743static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E, 744 LValue &LV) { 745 if (Ctx.getLangOptions().getGCMode() == LangOptions::NonGC) 746 return; 747 748 if (isa<ObjCIvarRefExpr>(E)) { 749 LV.SetObjCIvar(LV, true); 750 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E)); 751 LV.setBaseIvarExp(Exp->getBase()); 752 LV.SetObjCArray(LV, E->getType()->isArrayType()); 753 return; 754 } 755 756 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) { 757 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) { 758 if ((VD->isBlockVarDecl() && !VD->hasLocalStorage()) || 759 VD->isFileVarDecl()) 760 LV.SetGlobalObjCRef(LV, true); 761 } 762 LV.SetObjCArray(LV, E->getType()->isArrayType()); 763 return; 764 } 765 766 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) { 767 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 768 return; 769 } 770 771 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) { 772 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 773 if (LV.isObjCIvar()) { 774 // If cast is to a structure pointer, follow gcc's behavior and make it 775 // a non-ivar write-barrier. 776 QualType ExpTy = E->getType(); 777 if (ExpTy->isPointerType()) 778 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); 779 if (ExpTy->isRecordType()) 780 LV.SetObjCIvar(LV, false); 781 } 782 return; 783 } 784 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) { 785 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 786 return; 787 } 788 789 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) { 790 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 791 return; 792 } 793 794 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) { 795 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 796 if (LV.isObjCIvar() && !LV.isObjCArray()) 797 // Using array syntax to assigning to what an ivar points to is not 798 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0; 799 LV.SetObjCIvar(LV, false); 800 else if (LV.isGlobalObjCRef() && !LV.isObjCArray()) 801 // Using array syntax to assigning to what global points to is not 802 // same as assigning to the global itself. {id *G;} G[i] = 0; 803 LV.SetGlobalObjCRef(LV, false); 804 return; 805 } 806 807 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) { 808 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 809 // We don't know if member is an 'ivar', but this flag is looked at 810 // only in the context of LV.isObjCIvar(). 811 LV.SetObjCArray(LV, E->getType()->isArrayType()); 812 return; 813 } 814} 815 816LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { 817 const NamedDecl *ND = E->getDecl(); 818 819 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) { 820 LValue LV; 821 822 // Check if this is a global variable. 823 if (VD->hasExternalStorage() || VD->isFileVarDecl()) { 824 llvm::Value *V = CGM.GetAddrOfGlobalVar(VD); 825 if (VD->getType()->isReferenceType()) 826 V = Builder.CreateLoad(V, "tmp"); 827 LV = LValue::MakeAddr(V, MakeQualifiers(E->getType())); 828 setObjCGCLValueClass(getContext(), E, LV); 829 return LV; 830 } 831 832 bool NonGCable = VD->hasLocalStorage() && !VD->hasAttr<BlocksAttr>(); 833 834 llvm::Value *V = LocalDeclMap[VD]; 835 assert(V && "DeclRefExpr not entered in LocalDeclMap?"); 836 837 Qualifiers Quals = MakeQualifiers(E->getType()); 838 // local variables do not get their gc attribute set. 839 // local static? 840 if (NonGCable) Quals.removeObjCGCAttr(); 841 842 if (VD->hasAttr<BlocksAttr>()) { 843 V = Builder.CreateStructGEP(V, 1, "forwarding"); 844 V = Builder.CreateLoad(V, false); 845 V = Builder.CreateStructGEP(V, getByRefValueLLVMField(VD), 846 VD->getNameAsString()); 847 } 848 if (VD->getType()->isReferenceType()) 849 V = Builder.CreateLoad(V, "tmp"); 850 LV = LValue::MakeAddr(V, Quals); 851 LValue::SetObjCNonGC(LV, NonGCable); 852 setObjCGCLValueClass(getContext(), E, LV); 853 return LV; 854 } 855 856 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) { 857 llvm::Value* V = CGM.GetAddrOfFunction(FD); 858 if (!FD->hasPrototype()) { 859 if (const FunctionProtoType *Proto = 860 FD->getType()->getAs<FunctionProtoType>()) { 861 // Ugly case: for a K&R-style definition, the type of the definition 862 // isn't the same as the type of a use. Correct for this with a 863 // bitcast. 864 QualType NoProtoType = 865 getContext().getFunctionNoProtoType(Proto->getResultType()); 866 NoProtoType = getContext().getPointerType(NoProtoType); 867 V = Builder.CreateBitCast(V, ConvertType(NoProtoType), "tmp"); 868 } 869 } 870 return LValue::MakeAddr(V, MakeQualifiers(E->getType())); 871 } 872 873 if (E->getQualifier()) { 874 // FIXME: the qualifier check does not seem sufficient here 875 return EmitPointerToDataMemberLValue(cast<FieldDecl>(ND)); 876 } 877 878 assert(false && "Unhandled DeclRefExpr"); 879 880 // an invalid LValue, but the assert will 881 // ensure that this point is never reached. 882 return LValue(); 883} 884 885LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) { 886 return LValue::MakeAddr(GetAddrOfBlockDecl(E), MakeQualifiers(E->getType())); 887} 888 889LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { 890 // __extension__ doesn't affect lvalue-ness. 891 if (E->getOpcode() == UnaryOperator::Extension) 892 return EmitLValue(E->getSubExpr()); 893 894 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType()); 895 switch (E->getOpcode()) { 896 default: assert(0 && "Unknown unary operator lvalue!"); 897 case UnaryOperator::Deref: { 898 QualType T = E->getSubExpr()->getType()->getPointeeType(); 899 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type"); 900 901 Qualifiers Quals = MakeQualifiers(T); 902 Quals.setAddressSpace(ExprTy.getAddressSpace()); 903 904 LValue LV = LValue::MakeAddr(EmitScalarExpr(E->getSubExpr()), Quals); 905 // We should not generate __weak write barrier on indirect reference 906 // of a pointer to object; as in void foo (__weak id *param); *param = 0; 907 // But, we continue to generate __strong write barrier on indirect write 908 // into a pointer to object. 909 if (getContext().getLangOptions().ObjC1 && 910 getContext().getLangOptions().getGCMode() != LangOptions::NonGC && 911 LV.isObjCWeak()) 912 LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate(getContext())); 913 return LV; 914 } 915 case UnaryOperator::Real: 916 case UnaryOperator::Imag: 917 LValue LV = EmitLValue(E->getSubExpr()); 918 unsigned Idx = E->getOpcode() == UnaryOperator::Imag; 919 return LValue::MakeAddr(Builder.CreateStructGEP(LV.getAddress(), 920 Idx, "idx"), 921 MakeQualifiers(ExprTy)); 922 } 923} 924 925LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { 926 return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromLiteral(E), 927 Qualifiers()); 928} 929 930LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) { 931 return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromObjCEncode(E), 932 Qualifiers()); 933} 934 935 936LValue CodeGenFunction::EmitPredefinedFunctionName(unsigned Type) { 937 std::string GlobalVarName; 938 939 switch (Type) { 940 default: assert(0 && "Invalid type"); 941 case PredefinedExpr::Func: 942 GlobalVarName = "__func__."; 943 break; 944 case PredefinedExpr::Function: 945 GlobalVarName = "__FUNCTION__."; 946 break; 947 case PredefinedExpr::PrettyFunction: 948 GlobalVarName = "__PRETTY_FUNCTION__."; 949 break; 950 } 951 952 llvm::StringRef FnName = CurFn->getName(); 953 if (FnName.startswith("\01")) 954 FnName = FnName.substr(1); 955 GlobalVarName += FnName; 956 957 std::string FunctionName = 958 PredefinedExpr::ComputeName(getContext(), (PredefinedExpr::IdentType)Type, 959 CurCodeDecl); 960 961 llvm::Constant *C = 962 CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str()); 963 return LValue::MakeAddr(C, Qualifiers()); 964} 965 966LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { 967 switch (E->getIdentType()) { 968 default: 969 return EmitUnsupportedLValue(E, "predefined expression"); 970 case PredefinedExpr::Func: 971 case PredefinedExpr::Function: 972 case PredefinedExpr::PrettyFunction: 973 return EmitPredefinedFunctionName(E->getIdentType()); 974 } 975} 976 977LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { 978 // The index must always be an integer, which is not an aggregate. Emit it. 979 llvm::Value *Idx = EmitScalarExpr(E->getIdx()); 980 QualType IdxTy = E->getIdx()->getType(); 981 bool IdxSigned = IdxTy->isSignedIntegerType(); 982 983 // If the base is a vector type, then we are forming a vector element lvalue 984 // with this subscript. 985 if (E->getBase()->getType()->isVectorType()) { 986 // Emit the vector as an lvalue to get its address. 987 LValue LHS = EmitLValue(E->getBase()); 988 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 989 Idx = Builder.CreateIntCast(Idx, 990 llvm::Type::getInt32Ty(VMContext), IdxSigned, "vidx"); 991 return LValue::MakeVectorElt(LHS.getAddress(), Idx, 992 E->getBase()->getType().getCVRQualifiers()); 993 } 994 995 // The base must be a pointer, which is not an aggregate. Emit it. 996 llvm::Value *Base = EmitScalarExpr(E->getBase()); 997 998 // Extend or truncate the index type to 32 or 64-bits. 999 unsigned IdxBitwidth = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 1000 if (IdxBitwidth != LLVMPointerWidth) 1001 Idx = Builder.CreateIntCast(Idx, 1002 llvm::IntegerType::get(VMContext, LLVMPointerWidth), 1003 IdxSigned, "idxprom"); 1004 1005 // We know that the pointer points to a type of the correct size, unless the 1006 // size is a VLA or Objective-C interface. 1007 llvm::Value *Address = 0; 1008 if (const VariableArrayType *VAT = 1009 getContext().getAsVariableArrayType(E->getType())) { 1010 llvm::Value *VLASize = GetVLASize(VAT); 1011 1012 Idx = Builder.CreateMul(Idx, VLASize); 1013 1014 QualType BaseType = getContext().getBaseElementType(VAT); 1015 1016 uint64_t BaseTypeSize = getContext().getTypeSize(BaseType) / 8; 1017 Idx = Builder.CreateUDiv(Idx, 1018 llvm::ConstantInt::get(Idx->getType(), 1019 BaseTypeSize)); 1020 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx"); 1021 } else if (const ObjCInterfaceType *OIT = 1022 dyn_cast<ObjCInterfaceType>(E->getType())) { 1023 llvm::Value *InterfaceSize = 1024 llvm::ConstantInt::get(Idx->getType(), 1025 getContext().getTypeSize(OIT) / 8); 1026 1027 Idx = Builder.CreateMul(Idx, InterfaceSize); 1028 1029 const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext); 1030 Address = Builder.CreateGEP(Builder.CreateBitCast(Base, i8PTy), 1031 Idx, "arrayidx"); 1032 Address = Builder.CreateBitCast(Address, Base->getType()); 1033 } else { 1034 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx"); 1035 } 1036 1037 QualType T = E->getBase()->getType()->getPointeeType(); 1038 assert(!T.isNull() && 1039 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type"); 1040 1041 Qualifiers Quals = MakeQualifiers(T); 1042 Quals.setAddressSpace(E->getBase()->getType().getAddressSpace()); 1043 1044 LValue LV = LValue::MakeAddr(Address, Quals); 1045 if (getContext().getLangOptions().ObjC1 && 1046 getContext().getLangOptions().getGCMode() != LangOptions::NonGC) { 1047 LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate(getContext())); 1048 setObjCGCLValueClass(getContext(), E, LV); 1049 } 1050 return LV; 1051} 1052 1053static 1054llvm::Constant *GenerateConstantVector(llvm::LLVMContext &VMContext, 1055 llvm::SmallVector<unsigned, 4> &Elts) { 1056 llvm::SmallVector<llvm::Constant *, 4> CElts; 1057 1058 for (unsigned i = 0, e = Elts.size(); i != e; ++i) 1059 CElts.push_back(llvm::ConstantInt::get( 1060 llvm::Type::getInt32Ty(VMContext), Elts[i])); 1061 1062 return llvm::ConstantVector::get(&CElts[0], CElts.size()); 1063} 1064 1065LValue CodeGenFunction:: 1066EmitExtVectorElementExpr(const ExtVectorElementExpr *E) { 1067 // Emit the base vector as an l-value. 1068 LValue Base; 1069 1070 // ExtVectorElementExpr's base can either be a vector or pointer to vector. 1071 if (!E->isArrow()) { 1072 assert(E->getBase()->getType()->isVectorType()); 1073 Base = EmitLValue(E->getBase()); 1074 } else { 1075 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>(); 1076 llvm::Value *Ptr = EmitScalarExpr(E->getBase()); 1077 Qualifiers Quals = MakeQualifiers(PT->getPointeeType()); 1078 Quals.removeObjCGCAttr(); 1079 Base = LValue::MakeAddr(Ptr, Quals); 1080 } 1081 1082 // Encode the element access list into a vector of unsigned indices. 1083 llvm::SmallVector<unsigned, 4> Indices; 1084 E->getEncodedElementAccess(Indices); 1085 1086 if (Base.isSimple()) { 1087 llvm::Constant *CV = GenerateConstantVector(VMContext, Indices); 1088 return LValue::MakeExtVectorElt(Base.getAddress(), CV, 1089 Base.getVRQualifiers()); 1090 } 1091 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!"); 1092 1093 llvm::Constant *BaseElts = Base.getExtVectorElts(); 1094 llvm::SmallVector<llvm::Constant *, 4> CElts; 1095 1096 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext); 1097 for (unsigned i = 0, e = Indices.size(); i != e; ++i) { 1098 if (isa<llvm::ConstantAggregateZero>(BaseElts)) 1099 CElts.push_back(llvm::ConstantInt::get(Int32Ty, 0)); 1100 else 1101 CElts.push_back(cast<llvm::Constant>(BaseElts->getOperand(Indices[i]))); 1102 } 1103 llvm::Constant *CV = llvm::ConstantVector::get(&CElts[0], CElts.size()); 1104 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, 1105 Base.getVRQualifiers()); 1106} 1107 1108LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { 1109 bool isUnion = false; 1110 bool isNonGC = false; 1111 Expr *BaseExpr = E->getBase(); 1112 llvm::Value *BaseValue = NULL; 1113 Qualifiers BaseQuals; 1114 1115 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 1116 if (E->isArrow()) { 1117 BaseValue = EmitScalarExpr(BaseExpr); 1118 const PointerType *PTy = 1119 BaseExpr->getType()->getAs<PointerType>(); 1120 if (PTy->getPointeeType()->isUnionType()) 1121 isUnion = true; 1122 BaseQuals = PTy->getPointeeType().getQualifiers(); 1123 } else if (isa<ObjCPropertyRefExpr>(BaseExpr->IgnoreParens()) || 1124 isa<ObjCImplicitSetterGetterRefExpr>( 1125 BaseExpr->IgnoreParens())) { 1126 RValue RV = EmitObjCPropertyGet(BaseExpr); 1127 BaseValue = RV.getAggregateAddr(); 1128 if (BaseExpr->getType()->isUnionType()) 1129 isUnion = true; 1130 BaseQuals = BaseExpr->getType().getQualifiers(); 1131 } else { 1132 LValue BaseLV = EmitLValue(BaseExpr); 1133 if (BaseLV.isNonGC()) 1134 isNonGC = true; 1135 // FIXME: this isn't right for bitfields. 1136 BaseValue = BaseLV.getAddress(); 1137 QualType BaseTy = BaseExpr->getType(); 1138 if (BaseTy->isUnionType()) 1139 isUnion = true; 1140 BaseQuals = BaseTy.getQualifiers(); 1141 } 1142 1143 FieldDecl *Field = dyn_cast<FieldDecl>(E->getMemberDecl()); 1144 // FIXME: Handle non-field member expressions 1145 assert(Field && "No code generation for non-field member references"); 1146 LValue MemExpLV = EmitLValueForField(BaseValue, Field, isUnion, 1147 BaseQuals.getCVRQualifiers()); 1148 LValue::SetObjCNonGC(MemExpLV, isNonGC); 1149 setObjCGCLValueClass(getContext(), E, MemExpLV); 1150 return MemExpLV; 1151} 1152 1153LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value* BaseValue, 1154 FieldDecl* Field, 1155 unsigned CVRQualifiers) { 1156 CodeGenTypes::BitFieldInfo Info = CGM.getTypes().getBitFieldInfo(Field); 1157 1158 // FIXME: CodeGenTypes should expose a method to get the appropriate type for 1159 // FieldTy (the appropriate type is ABI-dependent). 1160 const llvm::Type *FieldTy = 1161 CGM.getTypes().ConvertTypeForMem(Field->getType()); 1162 const llvm::PointerType *BaseTy = 1163 cast<llvm::PointerType>(BaseValue->getType()); 1164 unsigned AS = BaseTy->getAddressSpace(); 1165 BaseValue = Builder.CreateBitCast(BaseValue, 1166 llvm::PointerType::get(FieldTy, AS), 1167 "tmp"); 1168 1169 llvm::Value *Idx = 1170 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Info.FieldNo); 1171 llvm::Value *V = Builder.CreateGEP(BaseValue, Idx, "tmp"); 1172 1173 return LValue::MakeBitfield(V, Info.Start, Info.Size, 1174 Field->getType()->isSignedIntegerType(), 1175 Field->getType().getCVRQualifiers()|CVRQualifiers); 1176} 1177 1178LValue CodeGenFunction::EmitLValueForField(llvm::Value* BaseValue, 1179 FieldDecl* Field, 1180 bool isUnion, 1181 unsigned CVRQualifiers) { 1182 if (Field->isBitField()) 1183 return EmitLValueForBitfield(BaseValue, Field, CVRQualifiers); 1184 1185 unsigned idx = CGM.getTypes().getLLVMFieldNo(Field); 1186 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp"); 1187 1188 // Match union field type. 1189 if (isUnion) { 1190 const llvm::Type *FieldTy = 1191 CGM.getTypes().ConvertTypeForMem(Field->getType()); 1192 const llvm::PointerType * BaseTy = 1193 cast<llvm::PointerType>(BaseValue->getType()); 1194 unsigned AS = BaseTy->getAddressSpace(); 1195 V = Builder.CreateBitCast(V, 1196 llvm::PointerType::get(FieldTy, AS), 1197 "tmp"); 1198 } 1199 if (Field->getType()->isReferenceType()) 1200 V = Builder.CreateLoad(V, "tmp"); 1201 1202 Qualifiers Quals = MakeQualifiers(Field->getType()); 1203 Quals.addCVRQualifiers(CVRQualifiers); 1204 // __weak attribute on a field is ignored. 1205 if (Quals.getObjCGCAttr() == Qualifiers::Weak) 1206 Quals.removeObjCGCAttr(); 1207 1208 return LValue::MakeAddr(V, Quals); 1209} 1210 1211LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr* E){ 1212 const llvm::Type *LTy = ConvertType(E->getType()); 1213 llvm::Value *DeclPtr = CreateTempAlloca(LTy, ".compoundliteral"); 1214 1215 const Expr* InitExpr = E->getInitializer(); 1216 LValue Result = LValue::MakeAddr(DeclPtr, MakeQualifiers(E->getType())); 1217 1218 if (E->getType()->isComplexType()) 1219 EmitComplexExprIntoAddr(InitExpr, DeclPtr, false); 1220 else if (hasAggregateLLVMType(E->getType())) 1221 EmitAnyExpr(InitExpr, DeclPtr, false); 1222 else 1223 EmitStoreThroughLValue(EmitAnyExpr(InitExpr), Result, E->getType()); 1224 1225 return Result; 1226} 1227 1228LValue 1229CodeGenFunction::EmitConditionalOperatorLValue(const ConditionalOperator* E) { 1230 if (E->isLvalue(getContext()) == Expr::LV_Valid) { 1231 llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 1232 llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 1233 llvm::BasicBlock *ContBlock = createBasicBlock("cond.end"); 1234 1235 llvm::Value *Cond = EvaluateExprAsBool(E->getCond()); 1236 Builder.CreateCondBr(Cond, LHSBlock, RHSBlock); 1237 1238 EmitBlock(LHSBlock); 1239 1240 LValue LHS = EmitLValue(E->getLHS()); 1241 if (!LHS.isSimple()) 1242 return EmitUnsupportedLValue(E, "conditional operator"); 1243 1244 llvm::Value *Temp = CreateTempAlloca(LHS.getAddress()->getType(),"condtmp"); 1245 Builder.CreateStore(LHS.getAddress(), Temp); 1246 EmitBranch(ContBlock); 1247 1248 EmitBlock(RHSBlock); 1249 LValue RHS = EmitLValue(E->getRHS()); 1250 if (!RHS.isSimple()) 1251 return EmitUnsupportedLValue(E, "conditional operator"); 1252 1253 Builder.CreateStore(RHS.getAddress(), Temp); 1254 EmitBranch(ContBlock); 1255 1256 EmitBlock(ContBlock); 1257 1258 Temp = Builder.CreateLoad(Temp, "lv"); 1259 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1260 } 1261 1262 // ?: here should be an aggregate. 1263 assert((hasAggregateLLVMType(E->getType()) && 1264 !E->getType()->isAnyComplexType()) && 1265 "Unexpected conditional operator!"); 1266 1267 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1268 EmitAggExpr(E, Temp, false); 1269 1270 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1271} 1272 1273/// EmitCastLValue - Casts are never lvalues. If a cast is needed by the code 1274/// generator in an lvalue context, then it must mean that we need the address 1275/// of an aggregate in order to access one of its fields. This can happen for 1276/// all the reasons that casts are permitted with aggregate result, including 1277/// noop aggregate casts, and cast from scalar to union. 1278LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { 1279 switch (E->getCastKind()) { 1280 default: 1281 // If this is an lvalue cast, treat it as a no-op. 1282 // FIXME: We shouldn't need to check for this explicitly! 1283 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(E)) 1284 if (ICE->isLvalueCast()) 1285 return EmitLValue(E->getSubExpr()); 1286 1287 assert(0 && "Unhandled cast!"); 1288 1289 case CastExpr::CK_NoOp: 1290 case CastExpr::CK_ConstructorConversion: 1291 case CastExpr::CK_UserDefinedConversion: 1292 return EmitLValue(E->getSubExpr()); 1293 1294 case CastExpr::CK_DerivedToBase: { 1295 const RecordType *DerivedClassTy = 1296 E->getSubExpr()->getType()->getAs<RecordType>(); 1297 CXXRecordDecl *DerivedClassDecl = 1298 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1299 1300 const RecordType *BaseClassTy = E->getType()->getAs<RecordType>(); 1301 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseClassTy->getDecl()); 1302 1303 LValue LV = EmitLValue(E->getSubExpr()); 1304 1305 // Perform the derived-to-base conversion 1306 llvm::Value *Base = 1307 GetAddressCXXOfBaseClass(LV.getAddress(), DerivedClassDecl, 1308 BaseClassDecl, /*NullCheckValue=*/false); 1309 1310 return LValue::MakeAddr(Base, MakeQualifiers(E->getType())); 1311 } 1312 1313 case CastExpr::CK_ToUnion: { 1314 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1315 EmitAnyExpr(E->getSubExpr(), Temp, false); 1316 1317 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1318 } 1319 } 1320} 1321 1322LValue CodeGenFunction::EmitNullInitializationLValue( 1323 const CXXZeroInitValueExpr *E) { 1324 QualType Ty = E->getType(); 1325 const llvm::Type *LTy = ConvertTypeForMem(Ty); 1326 llvm::AllocaInst *Alloc = CreateTempAlloca(LTy); 1327 unsigned Align = getContext().getTypeAlign(Ty)/8; 1328 Alloc->setAlignment(Align); 1329 LValue lvalue = LValue::MakeAddr(Alloc, Qualifiers()); 1330 EmitMemSetToZero(lvalue.getAddress(), Ty); 1331 return lvalue; 1332} 1333 1334//===--------------------------------------------------------------------===// 1335// Expression Emission 1336//===--------------------------------------------------------------------===// 1337 1338 1339RValue CodeGenFunction::EmitCallExpr(const CallExpr *E) { 1340 // Builtins never have block type. 1341 if (E->getCallee()->getType()->isBlockPointerType()) 1342 return EmitBlockCallExpr(E); 1343 1344 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E)) 1345 return EmitCXXMemberCallExpr(CE); 1346 1347 const Decl *TargetDecl = 0; 1348 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) { 1349 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) { 1350 TargetDecl = DRE->getDecl(); 1351 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl)) 1352 if (unsigned builtinID = FD->getBuiltinID()) 1353 return EmitBuiltinExpr(FD, builtinID, E); 1354 } 1355 } 1356 1357 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E)) 1358 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl)) 1359 return EmitCXXOperatorMemberCallExpr(CE, MD); 1360 1361 if (isa<CXXPseudoDestructorExpr>(E->getCallee())) { 1362 // C++ [expr.pseudo]p1: 1363 // The result shall only be used as the operand for the function call 1364 // operator (), and the result of such a call has type void. The only 1365 // effect is the evaluation of the postfix-expression before the dot or 1366 // arrow. 1367 EmitScalarExpr(E->getCallee()); 1368 return RValue::get(0); 1369 } 1370 1371 llvm::Value *Callee = EmitScalarExpr(E->getCallee()); 1372 return EmitCall(Callee, E->getCallee()->getType(), 1373 E->arg_begin(), E->arg_end(), TargetDecl); 1374} 1375 1376LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) { 1377 // Comma expressions just emit their LHS then their RHS as an l-value. 1378 if (E->getOpcode() == BinaryOperator::Comma) { 1379 EmitAnyExpr(E->getLHS()); 1380 return EmitLValue(E->getRHS()); 1381 } 1382 1383 if (E->getOpcode() == BinaryOperator::PtrMemD || 1384 E->getOpcode() == BinaryOperator::PtrMemI) 1385 return EmitPointerToDataMemberBinaryExpr(E); 1386 1387 // Can only get l-value for binary operator expressions which are a 1388 // simple assignment of aggregate type. 1389 if (E->getOpcode() != BinaryOperator::Assign) 1390 return EmitUnsupportedLValue(E, "binary l-value expression"); 1391 1392 if (!hasAggregateLLVMType(E->getType())) { 1393 // Emit the LHS as an l-value. 1394 LValue LV = EmitLValue(E->getLHS()); 1395 1396 llvm::Value *RHS = EmitScalarExpr(E->getRHS()); 1397 EmitStoreOfScalar(RHS, LV.getAddress(), LV.isVolatileQualified(), 1398 E->getType()); 1399 return LV; 1400 } 1401 1402 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1403 EmitAggExpr(E, Temp, false); 1404 // FIXME: Are these qualifiers correct? 1405 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1406} 1407 1408LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) { 1409 RValue RV = EmitCallExpr(E); 1410 1411 if (!RV.isScalar()) 1412 return LValue::MakeAddr(RV.getAggregateAddr(),MakeQualifiers(E->getType())); 1413 1414 assert(E->getCallReturnType()->isReferenceType() && 1415 "Can't have a scalar return unless the return type is a " 1416 "reference type!"); 1417 1418 return LValue::MakeAddr(RV.getScalarVal(), MakeQualifiers(E->getType())); 1419} 1420 1421LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) { 1422 // FIXME: This shouldn't require another copy. 1423 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1424 EmitAggExpr(E, Temp, false); 1425 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1426} 1427 1428LValue 1429CodeGenFunction::EmitCXXConditionDeclLValue(const CXXConditionDeclExpr *E) { 1430 EmitLocalBlockVarDecl(*E->getVarDecl()); 1431 return EmitDeclRefLValue(E); 1432} 1433 1434LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) { 1435 llvm::Value *Temp = CreateTempAlloca(ConvertTypeForMem(E->getType()), "tmp"); 1436 EmitCXXConstructExpr(Temp, E); 1437 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1438} 1439 1440LValue 1441CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) { 1442 LValue LV = EmitLValue(E->getSubExpr()); 1443 PushCXXTemporary(E->getTemporary(), LV.getAddress()); 1444 return LV; 1445} 1446 1447LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) { 1448 // Can only get l-value for message expression returning aggregate type 1449 RValue RV = EmitObjCMessageExpr(E); 1450 // FIXME: can this be volatile? 1451 return LValue::MakeAddr(RV.getAggregateAddr(), MakeQualifiers(E->getType())); 1452} 1453 1454llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface, 1455 const ObjCIvarDecl *Ivar) { 1456 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar); 1457} 1458 1459LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy, 1460 llvm::Value *BaseValue, 1461 const ObjCIvarDecl *Ivar, 1462 unsigned CVRQualifiers) { 1463 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue, 1464 Ivar, CVRQualifiers); 1465} 1466 1467LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) { 1468 // FIXME: A lot of the code below could be shared with EmitMemberExpr. 1469 llvm::Value *BaseValue = 0; 1470 const Expr *BaseExpr = E->getBase(); 1471 Qualifiers BaseQuals; 1472 QualType ObjectTy; 1473 if (E->isArrow()) { 1474 BaseValue = EmitScalarExpr(BaseExpr); 1475 ObjectTy = BaseExpr->getType()->getPointeeType(); 1476 BaseQuals = ObjectTy.getQualifiers(); 1477 } else { 1478 LValue BaseLV = EmitLValue(BaseExpr); 1479 // FIXME: this isn't right for bitfields. 1480 BaseValue = BaseLV.getAddress(); 1481 ObjectTy = BaseExpr->getType(); 1482 BaseQuals = ObjectTy.getQualifiers(); 1483 } 1484 1485 LValue LV = 1486 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(), 1487 BaseQuals.getCVRQualifiers()); 1488 setObjCGCLValueClass(getContext(), E, LV); 1489 return LV; 1490} 1491 1492LValue 1493CodeGenFunction::EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E) { 1494 // This is a special l-value that just issues sends when we load or store 1495 // through it. 1496 return LValue::MakePropertyRef(E, E->getType().getCVRQualifiers()); 1497} 1498 1499LValue CodeGenFunction::EmitObjCKVCRefLValue( 1500 const ObjCImplicitSetterGetterRefExpr *E) { 1501 // This is a special l-value that just issues sends when we load or store 1502 // through it. 1503 return LValue::MakeKVCRef(E, E->getType().getCVRQualifiers()); 1504} 1505 1506LValue CodeGenFunction::EmitObjCSuperExprLValue(const ObjCSuperExpr *E) { 1507 return EmitUnsupportedLValue(E, "use of super"); 1508} 1509 1510LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) { 1511 // Can only get l-value for message expression returning aggregate type 1512 RValue RV = EmitAnyExprToTemp(E); 1513 // FIXME: can this be volatile? 1514 return LValue::MakeAddr(RV.getAggregateAddr(), MakeQualifiers(E->getType())); 1515} 1516 1517 1518LValue CodeGenFunction::EmitPointerToDataMemberLValue(const FieldDecl *Field) { 1519 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Field->getDeclContext()); 1520 QualType NNSpecTy = 1521 getContext().getCanonicalType( 1522 getContext().getTypeDeclType(const_cast<CXXRecordDecl*>(ClassDecl))); 1523 NNSpecTy = getContext().getPointerType(NNSpecTy); 1524 llvm::Value *V = llvm::Constant::getNullValue(ConvertType(NNSpecTy)); 1525 LValue MemExpLV = EmitLValueForField(V, const_cast<FieldDecl*>(Field), 1526 /*isUnion*/false, /*Qualifiers*/0); 1527 const llvm::Type *ResultType = ConvertType(getContext().getPointerDiffType()); 1528 V = Builder.CreatePtrToInt(MemExpLV.getAddress(), ResultType, "datamember"); 1529 return LValue::MakeAddr(V, MakeQualifiers(Field->getType())); 1530} 1531 1532RValue CodeGenFunction::EmitCall(llvm::Value *Callee, QualType CalleeType, 1533 CallExpr::const_arg_iterator ArgBeg, 1534 CallExpr::const_arg_iterator ArgEnd, 1535 const Decl *TargetDecl) { 1536 // Get the actual function type. The callee type will always be a pointer to 1537 // function type or a block pointer type. 1538 assert(CalleeType->isFunctionPointerType() && 1539 "Call must have function pointer type!"); 1540 1541 CalleeType = getContext().getCanonicalType(CalleeType); 1542 1543 QualType FnType = cast<PointerType>(CalleeType)->getPointeeType(); 1544 QualType ResultType = cast<FunctionType>(FnType)->getResultType(); 1545 1546 CallArgList Args; 1547 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd); 1548 1549 // FIXME: We should not need to do this, it should be part of the function 1550 // type. 1551 unsigned CallingConvention = 0; 1552 if (const llvm::Function *F = 1553 dyn_cast<llvm::Function>(Callee->stripPointerCasts())) 1554 CallingConvention = F->getCallingConv(); 1555 return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args, 1556 CallingConvention), 1557 Callee, Args, TargetDecl); 1558} 1559 1560LValue CodeGenFunction:: 1561EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) { 1562 llvm::Value *BaseV = EmitLValue(E->getLHS()).getAddress(); 1563 if (E->getOpcode() == BinaryOperator::PtrMemI) 1564 BaseV = Builder.CreateLoad(BaseV, "indir.ptr"); 1565 const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(getLLVMContext()); 1566 BaseV = Builder.CreateBitCast(BaseV, i8Ty); 1567 LValue RHSLV = EmitLValue(E->getRHS()); 1568 llvm::Value *OffsetV = 1569 EmitLoadOfLValue(RHSLV, E->getRHS()->getType()).getScalarVal(); 1570 const llvm::Type* ResultType = ConvertType(getContext().getPointerDiffType()); 1571 OffsetV = Builder.CreateBitCast(OffsetV, ResultType); 1572 llvm::Value *AddV = Builder.CreateInBoundsGEP(BaseV, OffsetV, "add.ptr"); 1573 1574 QualType Ty = E->getRHS()->getType(); 1575 Ty = Ty->getAs<MemberPointerType>()->getPointeeType(); 1576 1577 const llvm::Type *PType = ConvertType(getContext().getPointerType(Ty)); 1578 AddV = Builder.CreateBitCast(AddV, PType); 1579 return LValue::MakeAddr(AddV, MakeQualifiers(Ty)); 1580} 1581 1582