CGExpr.cpp revision 130c69e969a785ff3be9e909f8eba7f89e42ac10
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 DelayedCleanupBlock 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 GetAddressOfBaseClass(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::CXXTemporaryObjectExprClass: 262 case Expr::CXXConstructExprClass: 263 return EmitCXXConstructLValue(cast<CXXConstructExpr>(E)); 264 case Expr::CXXBindTemporaryExprClass: 265 return EmitCXXBindTemporaryLValue(cast<CXXBindTemporaryExpr>(E)); 266 case Expr::CXXExprWithTemporariesClass: 267 return EmitCXXExprWithTemporariesLValue(cast<CXXExprWithTemporaries>(E)); 268 case Expr::CXXZeroInitValueExprClass: 269 return EmitNullInitializationLValue(cast<CXXZeroInitValueExpr>(E)); 270 case Expr::CXXDefaultArgExprClass: 271 return EmitLValue(cast<CXXDefaultArgExpr>(E)->getExpr()); 272 case Expr::CXXTypeidExprClass: 273 return EmitCXXTypeidLValue(cast<CXXTypeidExpr>(E)); 274 275 case Expr::ObjCMessageExprClass: 276 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E)); 277 case Expr::ObjCIvarRefExprClass: 278 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E)); 279 case Expr::ObjCPropertyRefExprClass: 280 return EmitObjCPropertyRefLValue(cast<ObjCPropertyRefExpr>(E)); 281 case Expr::ObjCImplicitSetterGetterRefExprClass: 282 return EmitObjCKVCRefLValue(cast<ObjCImplicitSetterGetterRefExpr>(E)); 283 case Expr::ObjCSuperExprClass: 284 return EmitObjCSuperExprLValue(cast<ObjCSuperExpr>(E)); 285 286 case Expr::StmtExprClass: 287 return EmitStmtExprLValue(cast<StmtExpr>(E)); 288 case Expr::UnaryOperatorClass: 289 return EmitUnaryOpLValue(cast<UnaryOperator>(E)); 290 case Expr::ArraySubscriptExprClass: 291 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E)); 292 case Expr::ExtVectorElementExprClass: 293 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E)); 294 case Expr::MemberExprClass: 295 return EmitMemberExpr(cast<MemberExpr>(E)); 296 case Expr::CompoundLiteralExprClass: 297 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E)); 298 case Expr::ConditionalOperatorClass: 299 return EmitConditionalOperatorLValue(cast<ConditionalOperator>(E)); 300 case Expr::ChooseExprClass: 301 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext())); 302 case Expr::ImplicitCastExprClass: 303 case Expr::CStyleCastExprClass: 304 case Expr::CXXFunctionalCastExprClass: 305 case Expr::CXXStaticCastExprClass: 306 case Expr::CXXDynamicCastExprClass: 307 case Expr::CXXReinterpretCastExprClass: 308 case Expr::CXXConstCastExprClass: 309 return EmitCastLValue(cast<CastExpr>(E)); 310 } 311} 312 313llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile, 314 QualType Ty) { 315 llvm::LoadInst *Load = Builder.CreateLoad(Addr, "tmp"); 316 if (Volatile) 317 Load->setVolatile(true); 318 319 // Bool can have different representation in memory than in registers. 320 llvm::Value *V = Load; 321 if (Ty->isBooleanType()) 322 if (V->getType() != llvm::Type::getInt1Ty(VMContext)) 323 V = Builder.CreateTrunc(V, llvm::Type::getInt1Ty(VMContext), "tobool"); 324 325 return V; 326} 327 328void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr, 329 bool Volatile, QualType Ty) { 330 331 if (Ty->isBooleanType()) { 332 // Bool can have different representation in memory than in registers. 333 const llvm::PointerType *DstPtr = cast<llvm::PointerType>(Addr->getType()); 334 Value = Builder.CreateIntCast(Value, DstPtr->getElementType(), false); 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, StartBit, "bf.lo"); 407 408 // Mask off unused bits. 409 llvm::Constant *LowMask = llvm::ConstantInt::get(VMContext, 410 llvm::APInt::getLowBitsSet(EltTySize, LowBits)); 411 Val = Builder.CreateAnd(Val, LowMask, "bf.lo.cleared"); 412 413 // Fetch the high bits if necessary. 414 if (LowBits < BitfieldSize) { 415 unsigned HighBits = BitfieldSize - LowBits; 416 llvm::Value *HighPtr = Builder.CreateGEP(Ptr, llvm::ConstantInt::get( 417 llvm::Type::getInt32Ty(VMContext), 1), "bf.ptr.hi"); 418 llvm::Value *HighVal = Builder.CreateLoad(HighPtr, 419 LV.isVolatileQualified(), 420 "tmp"); 421 422 // Mask off unused bits. 423 llvm::Constant *HighMask = llvm::ConstantInt::get(VMContext, 424 llvm::APInt::getLowBitsSet(EltTySize, HighBits)); 425 HighVal = Builder.CreateAnd(HighVal, HighMask, "bf.lo.cleared"); 426 427 // Shift to proper location and or in to bitfield value. 428 HighVal = Builder.CreateShl(HighVal, LowBits); 429 Val = Builder.CreateOr(Val, HighVal, "bf.val"); 430 } 431 432 // Sign extend if necessary. 433 if (LV.isBitfieldSigned()) { 434 llvm::Value *ExtraBits = llvm::ConstantInt::get(EltTy, 435 EltTySize - BitfieldSize); 436 Val = Builder.CreateAShr(Builder.CreateShl(Val, ExtraBits), 437 ExtraBits, "bf.val.sext"); 438 } 439 440 // The bitfield type and the normal type differ when the storage sizes differ 441 // (currently just _Bool). 442 Val = Builder.CreateIntCast(Val, ConvertType(ExprType), false, "tmp"); 443 444 return RValue::get(Val); 445} 446 447RValue CodeGenFunction::EmitLoadOfPropertyRefLValue(LValue LV, 448 QualType ExprType) { 449 return EmitObjCPropertyGet(LV.getPropertyRefExpr()); 450} 451 452RValue CodeGenFunction::EmitLoadOfKVCRefLValue(LValue LV, 453 QualType ExprType) { 454 return EmitObjCPropertyGet(LV.getKVCRefExpr()); 455} 456 457// If this is a reference to a subset of the elements of a vector, create an 458// appropriate shufflevector. 459RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV, 460 QualType ExprType) { 461 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(), 462 LV.isVolatileQualified(), "tmp"); 463 464 const llvm::Constant *Elts = LV.getExtVectorElts(); 465 466 // If the result of the expression is a non-vector type, we must be extracting 467 // a single element. Just codegen as an extractelement. 468 const VectorType *ExprVT = ExprType->getAs<VectorType>(); 469 if (!ExprVT) { 470 unsigned InIdx = getAccessedFieldNo(0, Elts); 471 llvm::Value *Elt = llvm::ConstantInt::get( 472 llvm::Type::getInt32Ty(VMContext), InIdx); 473 return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp")); 474 } 475 476 // Always use shuffle vector to try to retain the original program structure 477 unsigned NumResultElts = ExprVT->getNumElements(); 478 479 llvm::SmallVector<llvm::Constant*, 4> Mask; 480 for (unsigned i = 0; i != NumResultElts; ++i) { 481 unsigned InIdx = getAccessedFieldNo(i, Elts); 482 Mask.push_back(llvm::ConstantInt::get( 483 llvm::Type::getInt32Ty(VMContext), InIdx)); 484 } 485 486 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 487 Vec = Builder.CreateShuffleVector(Vec, 488 llvm::UndefValue::get(Vec->getType()), 489 MaskV, "tmp"); 490 return RValue::get(Vec); 491} 492 493 494 495/// EmitStoreThroughLValue - Store the specified rvalue into the specified 496/// lvalue, where both are guaranteed to the have the same type, and that type 497/// is 'Ty'. 498void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, 499 QualType Ty) { 500 if (!Dst.isSimple()) { 501 if (Dst.isVectorElt()) { 502 // Read/modify/write the vector, inserting the new element. 503 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(), 504 Dst.isVolatileQualified(), "tmp"); 505 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), 506 Dst.getVectorIdx(), "vecins"); 507 Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified()); 508 return; 509 } 510 511 // If this is an update of extended vector elements, insert them as 512 // appropriate. 513 if (Dst.isExtVectorElt()) 514 return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty); 515 516 if (Dst.isBitfield()) 517 return EmitStoreThroughBitfieldLValue(Src, Dst, Ty); 518 519 if (Dst.isPropertyRef()) 520 return EmitStoreThroughPropertyRefLValue(Src, Dst, Ty); 521 522 assert(Dst.isKVCRef() && "Unknown LValue type"); 523 return EmitStoreThroughKVCRefLValue(Src, Dst, Ty); 524 } 525 526 if (Dst.isObjCWeak() && !Dst.isNonGC()) { 527 // load of a __weak object. 528 llvm::Value *LvalueDst = Dst.getAddress(); 529 llvm::Value *src = Src.getScalarVal(); 530 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst); 531 return; 532 } 533 534 if (Dst.isObjCStrong() && !Dst.isNonGC()) { 535 // load of a __strong object. 536 llvm::Value *LvalueDst = Dst.getAddress(); 537 llvm::Value *src = Src.getScalarVal(); 538 if (Dst.isObjCIvar()) { 539 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL"); 540 const llvm::Type *ResultType = ConvertType(getContext().LongTy); 541 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp()); 542 llvm::Value *dst = RHS; 543 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 544 llvm::Value *LHS = 545 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast"); 546 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset"); 547 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst, 548 BytesBetween); 549 } else if (Dst.isGlobalObjCRef()) 550 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst); 551 else 552 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst); 553 return; 554 } 555 556 assert(Src.isScalar() && "Can't emit an agg store with this method"); 557 EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(), 558 Dst.isVolatileQualified(), Ty); 559} 560 561void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 562 QualType Ty, 563 llvm::Value **Result) { 564 unsigned StartBit = Dst.getBitfieldStartBit(); 565 unsigned BitfieldSize = Dst.getBitfieldSize(); 566 llvm::Value *Ptr = Dst.getBitfieldAddr(); 567 568 const llvm::Type *EltTy = 569 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 570 unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy); 571 572 // Get the new value, cast to the appropriate type and masked to exactly the 573 // size of the bit-field. 574 llvm::Value *SrcVal = Src.getScalarVal(); 575 llvm::Value *NewVal = Builder.CreateIntCast(SrcVal, EltTy, false, "tmp"); 576 llvm::Constant *Mask = llvm::ConstantInt::get(VMContext, 577 llvm::APInt::getLowBitsSet(EltTySize, BitfieldSize)); 578 NewVal = Builder.CreateAnd(NewVal, Mask, "bf.value"); 579 580 // Return the new value of the bit-field, if requested. 581 if (Result) { 582 // Cast back to the proper type for result. 583 const llvm::Type *SrcTy = SrcVal->getType(); 584 llvm::Value *SrcTrunc = Builder.CreateIntCast(NewVal, SrcTy, false, 585 "bf.reload.val"); 586 587 // Sign extend if necessary. 588 if (Dst.isBitfieldSigned()) { 589 unsigned SrcTySize = CGM.getTargetData().getTypeSizeInBits(SrcTy); 590 llvm::Value *ExtraBits = llvm::ConstantInt::get(SrcTy, 591 SrcTySize - BitfieldSize); 592 SrcTrunc = Builder.CreateAShr(Builder.CreateShl(SrcTrunc, ExtraBits), 593 ExtraBits, "bf.reload.sext"); 594 } 595 596 *Result = SrcTrunc; 597 } 598 599 // In some cases the bitfield may straddle two memory locations. Emit the low 600 // part first and check to see if the high needs to be done. 601 unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit); 602 llvm::Value *LowVal = Builder.CreateLoad(Ptr, Dst.isVolatileQualified(), 603 "bf.prev.low"); 604 605 // Compute the mask for zero-ing the low part of this bitfield. 606 llvm::Constant *InvMask = 607 llvm::ConstantInt::get(VMContext, 608 ~llvm::APInt::getBitsSet(EltTySize, StartBit, StartBit + LowBits)); 609 610 // Compute the new low part as 611 // LowVal = (LowVal & InvMask) | (NewVal << StartBit), 612 // with the shift of NewVal implicitly stripping the high bits. 613 llvm::Value *NewLowVal = 614 Builder.CreateShl(NewVal, StartBit, "bf.value.lo"); 615 LowVal = Builder.CreateAnd(LowVal, InvMask, "bf.prev.lo.cleared"); 616 LowVal = Builder.CreateOr(LowVal, NewLowVal, "bf.new.lo"); 617 618 // Write back. 619 Builder.CreateStore(LowVal, Ptr, Dst.isVolatileQualified()); 620 621 // If the low part doesn't cover the bitfield emit a high part. 622 if (LowBits < BitfieldSize) { 623 unsigned HighBits = BitfieldSize - LowBits; 624 llvm::Value *HighPtr = Builder.CreateGEP(Ptr, llvm::ConstantInt::get( 625 llvm::Type::getInt32Ty(VMContext), 1), "bf.ptr.hi"); 626 llvm::Value *HighVal = Builder.CreateLoad(HighPtr, 627 Dst.isVolatileQualified(), 628 "bf.prev.hi"); 629 630 // Compute the mask for zero-ing the high part of this bitfield. 631 llvm::Constant *InvMask = 632 llvm::ConstantInt::get(VMContext, ~llvm::APInt::getLowBitsSet(EltTySize, 633 HighBits)); 634 635 // Compute the new high part as 636 // HighVal = (HighVal & InvMask) | (NewVal lshr LowBits), 637 // where the high bits of NewVal have already been cleared and the 638 // shift stripping the low bits. 639 llvm::Value *NewHighVal = 640 Builder.CreateLShr(NewVal, LowBits, "bf.value.high"); 641 HighVal = Builder.CreateAnd(HighVal, InvMask, "bf.prev.hi.cleared"); 642 HighVal = Builder.CreateOr(HighVal, NewHighVal, "bf.new.hi"); 643 644 // Write back. 645 Builder.CreateStore(HighVal, HighPtr, Dst.isVolatileQualified()); 646 } 647} 648 649void CodeGenFunction::EmitStoreThroughPropertyRefLValue(RValue Src, 650 LValue Dst, 651 QualType Ty) { 652 EmitObjCPropertySet(Dst.getPropertyRefExpr(), Src); 653} 654 655void CodeGenFunction::EmitStoreThroughKVCRefLValue(RValue Src, 656 LValue Dst, 657 QualType Ty) { 658 EmitObjCPropertySet(Dst.getKVCRefExpr(), Src); 659} 660 661void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, 662 LValue Dst, 663 QualType Ty) { 664 // This access turns into a read/modify/write of the vector. Load the input 665 // value now. 666 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(), 667 Dst.isVolatileQualified(), "tmp"); 668 const llvm::Constant *Elts = Dst.getExtVectorElts(); 669 670 llvm::Value *SrcVal = Src.getScalarVal(); 671 672 if (const VectorType *VTy = Ty->getAs<VectorType>()) { 673 unsigned NumSrcElts = VTy->getNumElements(); 674 unsigned NumDstElts = 675 cast<llvm::VectorType>(Vec->getType())->getNumElements(); 676 if (NumDstElts == NumSrcElts) { 677 // Use shuffle vector is the src and destination are the same number of 678 // elements and restore the vector mask since it is on the side it will be 679 // stored. 680 llvm::SmallVector<llvm::Constant*, 4> Mask(NumDstElts); 681 for (unsigned i = 0; i != NumSrcElts; ++i) { 682 unsigned InIdx = getAccessedFieldNo(i, Elts); 683 Mask[InIdx] = llvm::ConstantInt::get( 684 llvm::Type::getInt32Ty(VMContext), i); 685 } 686 687 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 688 Vec = Builder.CreateShuffleVector(SrcVal, 689 llvm::UndefValue::get(Vec->getType()), 690 MaskV, "tmp"); 691 } else if (NumDstElts > NumSrcElts) { 692 // Extended the source vector to the same length and then shuffle it 693 // into the destination. 694 // FIXME: since we're shuffling with undef, can we just use the indices 695 // into that? This could be simpler. 696 llvm::SmallVector<llvm::Constant*, 4> ExtMask; 697 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext); 698 unsigned i; 699 for (i = 0; i != NumSrcElts; ++i) 700 ExtMask.push_back(llvm::ConstantInt::get(Int32Ty, i)); 701 for (; i != NumDstElts; ++i) 702 ExtMask.push_back(llvm::UndefValue::get(Int32Ty)); 703 llvm::Value *ExtMaskV = llvm::ConstantVector::get(&ExtMask[0], 704 ExtMask.size()); 705 llvm::Value *ExtSrcVal = 706 Builder.CreateShuffleVector(SrcVal, 707 llvm::UndefValue::get(SrcVal->getType()), 708 ExtMaskV, "tmp"); 709 // build identity 710 llvm::SmallVector<llvm::Constant*, 4> Mask; 711 for (unsigned i = 0; i != NumDstElts; ++i) 712 Mask.push_back(llvm::ConstantInt::get(Int32Ty, i)); 713 714 // modify when what gets shuffled in 715 for (unsigned i = 0; i != NumSrcElts; ++i) { 716 unsigned Idx = getAccessedFieldNo(i, Elts); 717 Mask[Idx] = llvm::ConstantInt::get(Int32Ty, i+NumDstElts); 718 } 719 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 720 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp"); 721 } else { 722 // We should never shorten the vector 723 assert(0 && "unexpected shorten vector length"); 724 } 725 } else { 726 // If the Src is a scalar (not a vector) it must be updating one element. 727 unsigned InIdx = getAccessedFieldNo(0, Elts); 728 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext); 729 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx); 730 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp"); 731 } 732 733 Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified()); 734} 735 736// setObjCGCLValueClass - sets class of he lvalue for the purpose of 737// generating write-barries API. It is currently a global, ivar, 738// or neither. 739static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E, 740 LValue &LV) { 741 if (Ctx.getLangOptions().getGCMode() == LangOptions::NonGC) 742 return; 743 744 if (isa<ObjCIvarRefExpr>(E)) { 745 LV.SetObjCIvar(LV, true); 746 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E)); 747 LV.setBaseIvarExp(Exp->getBase()); 748 LV.SetObjCArray(LV, E->getType()->isArrayType()); 749 return; 750 } 751 752 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) { 753 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) { 754 if ((VD->isBlockVarDecl() && !VD->hasLocalStorage()) || 755 VD->isFileVarDecl()) 756 LV.SetGlobalObjCRef(LV, true); 757 } 758 LV.SetObjCArray(LV, E->getType()->isArrayType()); 759 return; 760 } 761 762 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) { 763 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 764 return; 765 } 766 767 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) { 768 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 769 if (LV.isObjCIvar()) { 770 // If cast is to a structure pointer, follow gcc's behavior and make it 771 // a non-ivar write-barrier. 772 QualType ExpTy = E->getType(); 773 if (ExpTy->isPointerType()) 774 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); 775 if (ExpTy->isRecordType()) 776 LV.SetObjCIvar(LV, false); 777 } 778 return; 779 } 780 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) { 781 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 782 return; 783 } 784 785 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) { 786 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 787 return; 788 } 789 790 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) { 791 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 792 if (LV.isObjCIvar() && !LV.isObjCArray()) 793 // Using array syntax to assigning to what an ivar points to is not 794 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0; 795 LV.SetObjCIvar(LV, false); 796 else if (LV.isGlobalObjCRef() && !LV.isObjCArray()) 797 // Using array syntax to assigning to what global points to is not 798 // same as assigning to the global itself. {id *G;} G[i] = 0; 799 LV.SetGlobalObjCRef(LV, false); 800 return; 801 } 802 803 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) { 804 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 805 // We don't know if member is an 'ivar', but this flag is looked at 806 // only in the context of LV.isObjCIvar(). 807 LV.SetObjCArray(LV, E->getType()->isArrayType()); 808 return; 809 } 810} 811 812static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF, 813 const Expr *E, const VarDecl *VD) { 814 assert((VD->hasExternalStorage() || VD->isFileVarDecl()) && 815 "Var decl must have external storage or be a file var decl!"); 816 817 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD); 818 if (VD->getType()->isReferenceType()) 819 V = CGF.Builder.CreateLoad(V, "tmp"); 820 LValue LV = LValue::MakeAddr(V, CGF.MakeQualifiers(E->getType())); 821 setObjCGCLValueClass(CGF.getContext(), E, LV); 822 return LV; 823} 824 825static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF, 826 const Expr *E, const FunctionDecl *FD) { 827 llvm::Value* V = CGF.CGM.GetAddrOfFunction(FD); 828 if (!FD->hasPrototype()) { 829 if (const FunctionProtoType *Proto = 830 FD->getType()->getAs<FunctionProtoType>()) { 831 // Ugly case: for a K&R-style definition, the type of the definition 832 // isn't the same as the type of a use. Correct for this with a 833 // bitcast. 834 QualType NoProtoType = 835 CGF.getContext().getFunctionNoProtoType(Proto->getResultType()); 836 NoProtoType = CGF.getContext().getPointerType(NoProtoType); 837 V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType), "tmp"); 838 } 839 } 840 return LValue::MakeAddr(V, CGF.MakeQualifiers(E->getType())); 841} 842 843LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { 844 const NamedDecl *ND = E->getDecl(); 845 846 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) { 847 848 // Check if this is a global variable. 849 if (VD->hasExternalStorage() || VD->isFileVarDecl()) 850 return EmitGlobalVarDeclLValue(*this, E, VD); 851 852 bool NonGCable = VD->hasLocalStorage() && !VD->hasAttr<BlocksAttr>(); 853 854 llvm::Value *V = LocalDeclMap[VD]; 855 assert(V && "DeclRefExpr not entered in LocalDeclMap?"); 856 857 Qualifiers Quals = MakeQualifiers(E->getType()); 858 // local variables do not get their gc attribute set. 859 // local static? 860 if (NonGCable) Quals.removeObjCGCAttr(); 861 862 if (VD->hasAttr<BlocksAttr>()) { 863 V = Builder.CreateStructGEP(V, 1, "forwarding"); 864 V = Builder.CreateLoad(V); 865 V = Builder.CreateStructGEP(V, getByRefValueLLVMField(VD), 866 VD->getNameAsString()); 867 } 868 if (VD->getType()->isReferenceType()) 869 V = Builder.CreateLoad(V, "tmp"); 870 LValue LV = LValue::MakeAddr(V, Quals); 871 LValue::SetObjCNonGC(LV, NonGCable); 872 setObjCGCLValueClass(getContext(), E, LV); 873 return LV; 874 } 875 876 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) 877 return EmitFunctionDeclLValue(*this, E, FD); 878 879 if (E->getQualifier()) { 880 // FIXME: the qualifier check does not seem sufficient here 881 return EmitPointerToDataMemberLValue(cast<FieldDecl>(ND)); 882 } 883 884 assert(false && "Unhandled DeclRefExpr"); 885 886 // an invalid LValue, but the assert will 887 // ensure that this point is never reached. 888 return LValue(); 889} 890 891LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) { 892 return LValue::MakeAddr(GetAddrOfBlockDecl(E), MakeQualifiers(E->getType())); 893} 894 895LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { 896 // __extension__ doesn't affect lvalue-ness. 897 if (E->getOpcode() == UnaryOperator::Extension) 898 return EmitLValue(E->getSubExpr()); 899 900 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType()); 901 switch (E->getOpcode()) { 902 default: assert(0 && "Unknown unary operator lvalue!"); 903 case UnaryOperator::Deref: { 904 QualType T = E->getSubExpr()->getType()->getPointeeType(); 905 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type"); 906 907 Qualifiers Quals = MakeQualifiers(T); 908 Quals.setAddressSpace(ExprTy.getAddressSpace()); 909 910 LValue LV = LValue::MakeAddr(EmitScalarExpr(E->getSubExpr()), Quals); 911 // We should not generate __weak write barrier on indirect reference 912 // of a pointer to object; as in void foo (__weak id *param); *param = 0; 913 // But, we continue to generate __strong write barrier on indirect write 914 // into a pointer to object. 915 if (getContext().getLangOptions().ObjC1 && 916 getContext().getLangOptions().getGCMode() != LangOptions::NonGC && 917 LV.isObjCWeak()) 918 LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate(getContext())); 919 return LV; 920 } 921 case UnaryOperator::Real: 922 case UnaryOperator::Imag: { 923 LValue LV = EmitLValue(E->getSubExpr()); 924 unsigned Idx = E->getOpcode() == UnaryOperator::Imag; 925 return LValue::MakeAddr(Builder.CreateStructGEP(LV.getAddress(), 926 Idx, "idx"), 927 MakeQualifiers(ExprTy)); 928 } 929 case UnaryOperator::PreInc: 930 case UnaryOperator::PreDec: 931 return EmitUnsupportedLValue(E, "pre-inc/dec expression"); 932 } 933} 934 935LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { 936 return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromLiteral(E), 937 Qualifiers()); 938} 939 940LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) { 941 return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromObjCEncode(E), 942 Qualifiers()); 943} 944 945 946LValue CodeGenFunction::EmitPredefinedFunctionName(unsigned Type) { 947 std::string GlobalVarName; 948 949 switch (Type) { 950 default: assert(0 && "Invalid type"); 951 case PredefinedExpr::Func: 952 GlobalVarName = "__func__."; 953 break; 954 case PredefinedExpr::Function: 955 GlobalVarName = "__FUNCTION__."; 956 break; 957 case PredefinedExpr::PrettyFunction: 958 GlobalVarName = "__PRETTY_FUNCTION__."; 959 break; 960 } 961 962 llvm::StringRef FnName = CurFn->getName(); 963 if (FnName.startswith("\01")) 964 FnName = FnName.substr(1); 965 GlobalVarName += FnName; 966 967 std::string FunctionName = 968 PredefinedExpr::ComputeName(getContext(), (PredefinedExpr::IdentType)Type, 969 CurCodeDecl); 970 971 llvm::Constant *C = 972 CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str()); 973 return LValue::MakeAddr(C, Qualifiers()); 974} 975 976LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { 977 switch (E->getIdentType()) { 978 default: 979 return EmitUnsupportedLValue(E, "predefined expression"); 980 case PredefinedExpr::Func: 981 case PredefinedExpr::Function: 982 case PredefinedExpr::PrettyFunction: 983 return EmitPredefinedFunctionName(E->getIdentType()); 984 } 985} 986 987LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { 988 // The index must always be an integer, which is not an aggregate. Emit it. 989 llvm::Value *Idx = EmitScalarExpr(E->getIdx()); 990 QualType IdxTy = E->getIdx()->getType(); 991 bool IdxSigned = IdxTy->isSignedIntegerType(); 992 993 // If the base is a vector type, then we are forming a vector element lvalue 994 // with this subscript. 995 if (E->getBase()->getType()->isVectorType()) { 996 // Emit the vector as an lvalue to get its address. 997 LValue LHS = EmitLValue(E->getBase()); 998 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 999 Idx = Builder.CreateIntCast(Idx, 1000 llvm::Type::getInt32Ty(VMContext), IdxSigned, "vidx"); 1001 return LValue::MakeVectorElt(LHS.getAddress(), Idx, 1002 E->getBase()->getType().getCVRQualifiers()); 1003 } 1004 1005 // The base must be a pointer, which is not an aggregate. Emit it. 1006 llvm::Value *Base = EmitScalarExpr(E->getBase()); 1007 1008 // Extend or truncate the index type to 32 or 64-bits. 1009 unsigned IdxBitwidth = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 1010 if (IdxBitwidth != LLVMPointerWidth) 1011 Idx = Builder.CreateIntCast(Idx, 1012 llvm::IntegerType::get(VMContext, LLVMPointerWidth), 1013 IdxSigned, "idxprom"); 1014 1015 // We know that the pointer points to a type of the correct size, unless the 1016 // size is a VLA or Objective-C interface. 1017 llvm::Value *Address = 0; 1018 if (const VariableArrayType *VAT = 1019 getContext().getAsVariableArrayType(E->getType())) { 1020 llvm::Value *VLASize = GetVLASize(VAT); 1021 1022 Idx = Builder.CreateMul(Idx, VLASize); 1023 1024 QualType BaseType = getContext().getBaseElementType(VAT); 1025 1026 uint64_t BaseTypeSize = getContext().getTypeSize(BaseType) / 8; 1027 Idx = Builder.CreateUDiv(Idx, 1028 llvm::ConstantInt::get(Idx->getType(), 1029 BaseTypeSize)); 1030 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx"); 1031 } else if (const ObjCInterfaceType *OIT = 1032 dyn_cast<ObjCInterfaceType>(E->getType())) { 1033 llvm::Value *InterfaceSize = 1034 llvm::ConstantInt::get(Idx->getType(), 1035 getContext().getTypeSize(OIT) / 8); 1036 1037 Idx = Builder.CreateMul(Idx, InterfaceSize); 1038 1039 const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext); 1040 Address = Builder.CreateGEP(Builder.CreateBitCast(Base, i8PTy), 1041 Idx, "arrayidx"); 1042 Address = Builder.CreateBitCast(Address, Base->getType()); 1043 } else { 1044 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx"); 1045 } 1046 1047 QualType T = E->getBase()->getType()->getPointeeType(); 1048 assert(!T.isNull() && 1049 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type"); 1050 1051 Qualifiers Quals = MakeQualifiers(T); 1052 Quals.setAddressSpace(E->getBase()->getType().getAddressSpace()); 1053 1054 LValue LV = LValue::MakeAddr(Address, Quals); 1055 if (getContext().getLangOptions().ObjC1 && 1056 getContext().getLangOptions().getGCMode() != LangOptions::NonGC) { 1057 LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate(getContext())); 1058 setObjCGCLValueClass(getContext(), E, LV); 1059 } 1060 return LV; 1061} 1062 1063static 1064llvm::Constant *GenerateConstantVector(llvm::LLVMContext &VMContext, 1065 llvm::SmallVector<unsigned, 4> &Elts) { 1066 llvm::SmallVector<llvm::Constant *, 4> CElts; 1067 1068 for (unsigned i = 0, e = Elts.size(); i != e; ++i) 1069 CElts.push_back(llvm::ConstantInt::get( 1070 llvm::Type::getInt32Ty(VMContext), Elts[i])); 1071 1072 return llvm::ConstantVector::get(&CElts[0], CElts.size()); 1073} 1074 1075LValue CodeGenFunction:: 1076EmitExtVectorElementExpr(const ExtVectorElementExpr *E) { 1077 // Emit the base vector as an l-value. 1078 LValue Base; 1079 1080 // ExtVectorElementExpr's base can either be a vector or pointer to vector. 1081 if (!E->isArrow()) { 1082 assert(E->getBase()->getType()->isVectorType()); 1083 Base = EmitLValue(E->getBase()); 1084 } else { 1085 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>(); 1086 llvm::Value *Ptr = EmitScalarExpr(E->getBase()); 1087 Qualifiers Quals = MakeQualifiers(PT->getPointeeType()); 1088 Quals.removeObjCGCAttr(); 1089 Base = LValue::MakeAddr(Ptr, Quals); 1090 } 1091 1092 // Encode the element access list into a vector of unsigned indices. 1093 llvm::SmallVector<unsigned, 4> Indices; 1094 E->getEncodedElementAccess(Indices); 1095 1096 if (Base.isSimple()) { 1097 llvm::Constant *CV = GenerateConstantVector(VMContext, Indices); 1098 return LValue::MakeExtVectorElt(Base.getAddress(), CV, 1099 Base.getVRQualifiers()); 1100 } 1101 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!"); 1102 1103 llvm::Constant *BaseElts = Base.getExtVectorElts(); 1104 llvm::SmallVector<llvm::Constant *, 4> CElts; 1105 1106 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext); 1107 for (unsigned i = 0, e = Indices.size(); i != e; ++i) { 1108 if (isa<llvm::ConstantAggregateZero>(BaseElts)) 1109 CElts.push_back(llvm::ConstantInt::get(Int32Ty, 0)); 1110 else 1111 CElts.push_back(cast<llvm::Constant>(BaseElts->getOperand(Indices[i]))); 1112 } 1113 llvm::Constant *CV = llvm::ConstantVector::get(&CElts[0], CElts.size()); 1114 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, 1115 Base.getVRQualifiers()); 1116} 1117 1118LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { 1119 bool isUnion = false; 1120 bool isNonGC = false; 1121 Expr *BaseExpr = E->getBase(); 1122 llvm::Value *BaseValue = NULL; 1123 Qualifiers BaseQuals; 1124 1125 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 1126 if (E->isArrow()) { 1127 BaseValue = EmitScalarExpr(BaseExpr); 1128 const PointerType *PTy = 1129 BaseExpr->getType()->getAs<PointerType>(); 1130 if (PTy->getPointeeType()->isUnionType()) 1131 isUnion = true; 1132 BaseQuals = PTy->getPointeeType().getQualifiers(); 1133 } else if (isa<ObjCPropertyRefExpr>(BaseExpr->IgnoreParens()) || 1134 isa<ObjCImplicitSetterGetterRefExpr>( 1135 BaseExpr->IgnoreParens())) { 1136 RValue RV = EmitObjCPropertyGet(BaseExpr); 1137 BaseValue = RV.getAggregateAddr(); 1138 if (BaseExpr->getType()->isUnionType()) 1139 isUnion = true; 1140 BaseQuals = BaseExpr->getType().getQualifiers(); 1141 } else { 1142 LValue BaseLV = EmitLValue(BaseExpr); 1143 if (BaseLV.isNonGC()) 1144 isNonGC = true; 1145 // FIXME: this isn't right for bitfields. 1146 BaseValue = BaseLV.getAddress(); 1147 QualType BaseTy = BaseExpr->getType(); 1148 if (BaseTy->isUnionType()) 1149 isUnion = true; 1150 BaseQuals = BaseTy.getQualifiers(); 1151 } 1152 1153 NamedDecl *ND = E->getMemberDecl(); 1154 if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) { 1155 LValue LV = EmitLValueForField(BaseValue, Field, isUnion, 1156 BaseQuals.getCVRQualifiers()); 1157 LValue::SetObjCNonGC(LV, isNonGC); 1158 setObjCGCLValueClass(getContext(), E, LV); 1159 return LV; 1160 } 1161 1162 if (VarDecl *VD = dyn_cast<VarDecl>(ND)) 1163 return EmitGlobalVarDeclLValue(*this, E, VD); 1164 1165 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) 1166 return EmitFunctionDeclLValue(*this, E, FD); 1167 1168 assert(false && "Unhandled member declaration!"); 1169 return LValue(); 1170} 1171 1172LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value* BaseValue, 1173 const FieldDecl* Field, 1174 unsigned CVRQualifiers) { 1175 CodeGenTypes::BitFieldInfo Info = CGM.getTypes().getBitFieldInfo(Field); 1176 1177 // FIXME: CodeGenTypes should expose a method to get the appropriate type for 1178 // FieldTy (the appropriate type is ABI-dependent). 1179 const llvm::Type *FieldTy = 1180 CGM.getTypes().ConvertTypeForMem(Field->getType()); 1181 const llvm::PointerType *BaseTy = 1182 cast<llvm::PointerType>(BaseValue->getType()); 1183 unsigned AS = BaseTy->getAddressSpace(); 1184 BaseValue = Builder.CreateBitCast(BaseValue, 1185 llvm::PointerType::get(FieldTy, AS), 1186 "tmp"); 1187 1188 llvm::Value *Idx = 1189 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), Info.FieldNo); 1190 llvm::Value *V = Builder.CreateGEP(BaseValue, Idx, "tmp"); 1191 1192 return LValue::MakeBitfield(V, Info.Start, Info.Size, 1193 Field->getType()->isSignedIntegerType(), 1194 Field->getType().getCVRQualifiers()|CVRQualifiers); 1195} 1196 1197LValue CodeGenFunction::EmitLValueForField(llvm::Value* BaseValue, 1198 const FieldDecl* Field, 1199 bool isUnion, 1200 unsigned CVRQualifiers) { 1201 if (Field->isBitField()) 1202 return EmitLValueForBitfield(BaseValue, Field, CVRQualifiers); 1203 1204 unsigned idx = CGM.getTypes().getLLVMFieldNo(Field); 1205 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp"); 1206 1207 // Match union field type. 1208 if (isUnion) { 1209 const llvm::Type *FieldTy = 1210 CGM.getTypes().ConvertTypeForMem(Field->getType()); 1211 const llvm::PointerType * BaseTy = 1212 cast<llvm::PointerType>(BaseValue->getType()); 1213 unsigned AS = BaseTy->getAddressSpace(); 1214 V = Builder.CreateBitCast(V, 1215 llvm::PointerType::get(FieldTy, AS), 1216 "tmp"); 1217 } 1218 if (Field->getType()->isReferenceType()) 1219 V = Builder.CreateLoad(V, "tmp"); 1220 1221 Qualifiers Quals = MakeQualifiers(Field->getType()); 1222 Quals.addCVRQualifiers(CVRQualifiers); 1223 // __weak attribute on a field is ignored. 1224 if (Quals.getObjCGCAttr() == Qualifiers::Weak) 1225 Quals.removeObjCGCAttr(); 1226 1227 return LValue::MakeAddr(V, Quals); 1228} 1229 1230LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr* E){ 1231 const llvm::Type *LTy = ConvertType(E->getType()); 1232 llvm::Value *DeclPtr = CreateTempAlloca(LTy, ".compoundliteral"); 1233 1234 const Expr* InitExpr = E->getInitializer(); 1235 LValue Result = LValue::MakeAddr(DeclPtr, MakeQualifiers(E->getType())); 1236 1237 if (E->getType()->isComplexType()) 1238 EmitComplexExprIntoAddr(InitExpr, DeclPtr, false); 1239 else if (hasAggregateLLVMType(E->getType())) 1240 EmitAnyExpr(InitExpr, DeclPtr, false); 1241 else 1242 EmitStoreThroughLValue(EmitAnyExpr(InitExpr), Result, E->getType()); 1243 1244 return Result; 1245} 1246 1247LValue 1248CodeGenFunction::EmitConditionalOperatorLValue(const ConditionalOperator* E) { 1249 if (E->isLvalue(getContext()) == Expr::LV_Valid) { 1250 llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 1251 llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 1252 llvm::BasicBlock *ContBlock = createBasicBlock("cond.end"); 1253 1254 llvm::Value *Cond = EvaluateExprAsBool(E->getCond()); 1255 Builder.CreateCondBr(Cond, LHSBlock, RHSBlock); 1256 1257 EmitBlock(LHSBlock); 1258 1259 LValue LHS = EmitLValue(E->getLHS()); 1260 if (!LHS.isSimple()) 1261 return EmitUnsupportedLValue(E, "conditional operator"); 1262 1263 llvm::Value *Temp = CreateTempAlloca(LHS.getAddress()->getType(),"condtmp"); 1264 Builder.CreateStore(LHS.getAddress(), Temp); 1265 EmitBranch(ContBlock); 1266 1267 EmitBlock(RHSBlock); 1268 LValue RHS = EmitLValue(E->getRHS()); 1269 if (!RHS.isSimple()) 1270 return EmitUnsupportedLValue(E, "conditional operator"); 1271 1272 Builder.CreateStore(RHS.getAddress(), Temp); 1273 EmitBranch(ContBlock); 1274 1275 EmitBlock(ContBlock); 1276 1277 Temp = Builder.CreateLoad(Temp, "lv"); 1278 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1279 } 1280 1281 // ?: here should be an aggregate. 1282 assert((hasAggregateLLVMType(E->getType()) && 1283 !E->getType()->isAnyComplexType()) && 1284 "Unexpected conditional operator!"); 1285 1286 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1287 EmitAggExpr(E, Temp, false); 1288 1289 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1290} 1291 1292/// EmitCastLValue - Casts are never lvalues unless that cast is a dynamic_cast. 1293/// If the cast is a dynamic_cast, we can have the usual lvalue result, 1294/// otherwise if a cast is needed by the code generator in an lvalue context, 1295/// then it must mean that we need the address of an aggregate in order to 1296/// access one of its fields. This can happen for all the reasons that casts 1297/// are permitted with aggregate result, including noop aggregate casts, and 1298/// cast from scalar to union. 1299LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { 1300 switch (E->getCastKind()) { 1301 default: 1302 return EmitUnsupportedLValue(E, "unexpected cast lvalue"); 1303 1304 case CastExpr::CK_Dynamic: { 1305 LValue LV = EmitLValue(E->getSubExpr()); 1306 llvm::Value *V = LV.getAddress(); 1307 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E); 1308 return LValue::MakeAddr(EmitDynamicCast(V, DCE), 1309 MakeQualifiers(E->getType())); 1310 } 1311 1312 case CastExpr::CK_NoOp: 1313 case CastExpr::CK_ConstructorConversion: 1314 case CastExpr::CK_UserDefinedConversion: 1315 return EmitLValue(E->getSubExpr()); 1316 1317 case CastExpr::CK_DerivedToBase: { 1318 const RecordType *DerivedClassTy = 1319 E->getSubExpr()->getType()->getAs<RecordType>(); 1320 CXXRecordDecl *DerivedClassDecl = 1321 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1322 1323 const RecordType *BaseClassTy = E->getType()->getAs<RecordType>(); 1324 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseClassTy->getDecl()); 1325 1326 LValue LV = EmitLValue(E->getSubExpr()); 1327 1328 // Perform the derived-to-base conversion 1329 llvm::Value *Base = 1330 GetAddressOfBaseClass(LV.getAddress(), DerivedClassDecl, 1331 BaseClassDecl, /*NullCheckValue=*/false); 1332 1333 return LValue::MakeAddr(Base, MakeQualifiers(E->getType())); 1334 } 1335 case CastExpr::CK_ToUnion: { 1336 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1337 EmitAnyExpr(E->getSubExpr(), Temp, false); 1338 1339 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1340 } 1341 case CastExpr::CK_BaseToDerived: { 1342 const RecordType *BaseClassTy = 1343 E->getSubExpr()->getType()->getAs<RecordType>(); 1344 CXXRecordDecl *BaseClassDecl = 1345 cast<CXXRecordDecl>(BaseClassTy->getDecl()); 1346 1347 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>(); 1348 CXXRecordDecl *DerivedClassDecl = 1349 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1350 1351 LValue LV = EmitLValue(E->getSubExpr()); 1352 1353 // Perform the base-to-derived conversion 1354 llvm::Value *Derived = 1355 GetAddressOfDerivedClass(LV.getAddress(), BaseClassDecl, 1356 DerivedClassDecl, /*NullCheckValue=*/false); 1357 1358 return LValue::MakeAddr(Derived, MakeQualifiers(E->getType())); 1359 } 1360 case CastExpr::CK_BitCast: { 1361 // This must be a reinterpret_cast (or c-style equivalent). 1362 const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E); 1363 1364 LValue LV = EmitLValue(E->getSubExpr()); 1365 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(), 1366 ConvertType(CE->getTypeAsWritten())); 1367 return LValue::MakeAddr(V, MakeQualifiers(E->getType())); 1368 } 1369 } 1370} 1371 1372LValue CodeGenFunction::EmitNullInitializationLValue( 1373 const CXXZeroInitValueExpr *E) { 1374 QualType Ty = E->getType(); 1375 const llvm::Type *LTy = ConvertTypeForMem(Ty); 1376 llvm::AllocaInst *Alloc = CreateTempAlloca(LTy); 1377 unsigned Align = getContext().getTypeAlign(Ty)/8; 1378 Alloc->setAlignment(Align); 1379 LValue lvalue = LValue::MakeAddr(Alloc, Qualifiers()); 1380 EmitMemSetToZero(lvalue.getAddress(), Ty); 1381 return lvalue; 1382} 1383 1384//===--------------------------------------------------------------------===// 1385// Expression Emission 1386//===--------------------------------------------------------------------===// 1387 1388 1389RValue CodeGenFunction::EmitCallExpr(const CallExpr *E) { 1390 // Builtins never have block type. 1391 if (E->getCallee()->getType()->isBlockPointerType()) 1392 return EmitBlockCallExpr(E); 1393 1394 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E)) 1395 return EmitCXXMemberCallExpr(CE); 1396 1397 const Decl *TargetDecl = 0; 1398 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) { 1399 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) { 1400 TargetDecl = DRE->getDecl(); 1401 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl)) 1402 if (unsigned builtinID = FD->getBuiltinID()) 1403 return EmitBuiltinExpr(FD, builtinID, E); 1404 } 1405 } 1406 1407 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E)) 1408 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl)) 1409 return EmitCXXOperatorMemberCallExpr(CE, MD); 1410 1411 if (isa<CXXPseudoDestructorExpr>(E->getCallee())) { 1412 // C++ [expr.pseudo]p1: 1413 // The result shall only be used as the operand for the function call 1414 // operator (), and the result of such a call has type void. The only 1415 // effect is the evaluation of the postfix-expression before the dot or 1416 // arrow. 1417 EmitScalarExpr(E->getCallee()); 1418 return RValue::get(0); 1419 } 1420 1421 llvm::Value *Callee = EmitScalarExpr(E->getCallee()); 1422 return EmitCall(Callee, E->getCallee()->getType(), 1423 E->arg_begin(), E->arg_end(), TargetDecl); 1424} 1425 1426LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) { 1427 // Comma expressions just emit their LHS then their RHS as an l-value. 1428 if (E->getOpcode() == BinaryOperator::Comma) { 1429 EmitAnyExpr(E->getLHS()); 1430 EnsureInsertPoint(); 1431 return EmitLValue(E->getRHS()); 1432 } 1433 1434 if (E->getOpcode() == BinaryOperator::PtrMemD || 1435 E->getOpcode() == BinaryOperator::PtrMemI) 1436 return EmitPointerToDataMemberBinaryExpr(E); 1437 1438 // Can only get l-value for binary operator expressions which are a 1439 // simple assignment of aggregate type. 1440 if (E->getOpcode() != BinaryOperator::Assign) 1441 return EmitUnsupportedLValue(E, "binary l-value expression"); 1442 1443 if (!hasAggregateLLVMType(E->getType())) { 1444 // Emit the LHS as an l-value. 1445 LValue LV = EmitLValue(E->getLHS()); 1446 1447 llvm::Value *RHS = EmitScalarExpr(E->getRHS()); 1448 EmitStoreOfScalar(RHS, LV.getAddress(), LV.isVolatileQualified(), 1449 E->getType()); 1450 return LV; 1451 } 1452 1453 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1454 EmitAggExpr(E, Temp, false); 1455 // FIXME: Are these qualifiers correct? 1456 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1457} 1458 1459LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) { 1460 RValue RV = EmitCallExpr(E); 1461 1462 if (!RV.isScalar()) 1463 return LValue::MakeAddr(RV.getAggregateAddr(),MakeQualifiers(E->getType())); 1464 1465 assert(E->getCallReturnType()->isReferenceType() && 1466 "Can't have a scalar return unless the return type is a " 1467 "reference type!"); 1468 1469 return LValue::MakeAddr(RV.getScalarVal(), MakeQualifiers(E->getType())); 1470} 1471 1472LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) { 1473 // FIXME: This shouldn't require another copy. 1474 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1475 EmitAggExpr(E, Temp, false); 1476 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1477} 1478 1479LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) { 1480 llvm::Value *Temp = CreateTempAlloca(ConvertTypeForMem(E->getType()), "tmp"); 1481 EmitCXXConstructExpr(Temp, E); 1482 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1483} 1484 1485LValue 1486CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) { 1487 llvm::Value *Temp = EmitCXXTypeidExpr(E); 1488 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1489} 1490 1491LValue 1492CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) { 1493 LValue LV = EmitLValue(E->getSubExpr()); 1494 PushCXXTemporary(E->getTemporary(), LV.getAddress()); 1495 return LV; 1496} 1497 1498LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) { 1499 // Can only get l-value for message expression returning aggregate type 1500 RValue RV = EmitObjCMessageExpr(E); 1501 // FIXME: can this be volatile? 1502 return LValue::MakeAddr(RV.getAggregateAddr(), MakeQualifiers(E->getType())); 1503} 1504 1505llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface, 1506 const ObjCIvarDecl *Ivar) { 1507 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar); 1508} 1509 1510LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy, 1511 llvm::Value *BaseValue, 1512 const ObjCIvarDecl *Ivar, 1513 unsigned CVRQualifiers) { 1514 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue, 1515 Ivar, CVRQualifiers); 1516} 1517 1518LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) { 1519 // FIXME: A lot of the code below could be shared with EmitMemberExpr. 1520 llvm::Value *BaseValue = 0; 1521 const Expr *BaseExpr = E->getBase(); 1522 Qualifiers BaseQuals; 1523 QualType ObjectTy; 1524 if (E->isArrow()) { 1525 BaseValue = EmitScalarExpr(BaseExpr); 1526 ObjectTy = BaseExpr->getType()->getPointeeType(); 1527 BaseQuals = ObjectTy.getQualifiers(); 1528 } else { 1529 LValue BaseLV = EmitLValue(BaseExpr); 1530 // FIXME: this isn't right for bitfields. 1531 BaseValue = BaseLV.getAddress(); 1532 ObjectTy = BaseExpr->getType(); 1533 BaseQuals = ObjectTy.getQualifiers(); 1534 } 1535 1536 LValue LV = 1537 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(), 1538 BaseQuals.getCVRQualifiers()); 1539 setObjCGCLValueClass(getContext(), E, LV); 1540 return LV; 1541} 1542 1543LValue 1544CodeGenFunction::EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E) { 1545 // This is a special l-value that just issues sends when we load or store 1546 // through it. 1547 return LValue::MakePropertyRef(E, E->getType().getCVRQualifiers()); 1548} 1549 1550LValue CodeGenFunction::EmitObjCKVCRefLValue( 1551 const ObjCImplicitSetterGetterRefExpr *E) { 1552 // This is a special l-value that just issues sends when we load or store 1553 // through it. 1554 return LValue::MakeKVCRef(E, E->getType().getCVRQualifiers()); 1555} 1556 1557LValue CodeGenFunction::EmitObjCSuperExprLValue(const ObjCSuperExpr *E) { 1558 return EmitUnsupportedLValue(E, "use of super"); 1559} 1560 1561LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) { 1562 // Can only get l-value for message expression returning aggregate type 1563 RValue RV = EmitAnyExprToTemp(E); 1564 // FIXME: can this be volatile? 1565 return LValue::MakeAddr(RV.getAggregateAddr(), MakeQualifiers(E->getType())); 1566} 1567 1568 1569LValue CodeGenFunction::EmitPointerToDataMemberLValue(const FieldDecl *Field) { 1570 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(Field->getDeclContext()); 1571 QualType NNSpecTy = 1572 getContext().getCanonicalType( 1573 getContext().getTypeDeclType(const_cast<CXXRecordDecl*>(ClassDecl))); 1574 NNSpecTy = getContext().getPointerType(NNSpecTy); 1575 llvm::Value *V = llvm::Constant::getNullValue(ConvertType(NNSpecTy)); 1576 LValue MemExpLV = EmitLValueForField(V, Field, /*isUnion=*/false, 1577 /*Qualifiers=*/0); 1578 const llvm::Type *ResultType = ConvertType(getContext().getPointerDiffType()); 1579 V = Builder.CreatePtrToInt(MemExpLV.getAddress(), ResultType, "datamember"); 1580 return LValue::MakeAddr(V, MakeQualifiers(Field->getType())); 1581} 1582 1583RValue CodeGenFunction::EmitCall(llvm::Value *Callee, QualType CalleeType, 1584 CallExpr::const_arg_iterator ArgBeg, 1585 CallExpr::const_arg_iterator ArgEnd, 1586 const Decl *TargetDecl) { 1587 // Get the actual function type. The callee type will always be a pointer to 1588 // function type or a block pointer type. 1589 assert(CalleeType->isFunctionPointerType() && 1590 "Call must have function pointer type!"); 1591 1592 CalleeType = getContext().getCanonicalType(CalleeType); 1593 1594 QualType FnType = cast<PointerType>(CalleeType)->getPointeeType(); 1595 QualType ResultType = cast<FunctionType>(FnType)->getResultType(); 1596 1597 CallArgList Args; 1598 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd); 1599 1600 // FIXME: We should not need to do this, it should be part of the function 1601 // type. 1602 unsigned CallingConvention = 0; 1603 if (const llvm::Function *F = 1604 dyn_cast<llvm::Function>(Callee->stripPointerCasts())) 1605 CallingConvention = F->getCallingConv(); 1606 return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args, 1607 CallingConvention), 1608 Callee, Args, TargetDecl); 1609} 1610 1611LValue CodeGenFunction:: 1612EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) { 1613 llvm::Value *BaseV; 1614 if (E->getOpcode() == BinaryOperator::PtrMemI) 1615 BaseV = EmitScalarExpr(E->getLHS()); 1616 else 1617 BaseV = EmitLValue(E->getLHS()).getAddress(); 1618 const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(getLLVMContext()); 1619 BaseV = Builder.CreateBitCast(BaseV, i8Ty); 1620 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS()); 1621 llvm::Value *AddV = Builder.CreateInBoundsGEP(BaseV, OffsetV, "add.ptr"); 1622 1623 QualType Ty = E->getRHS()->getType(); 1624 Ty = Ty->getAs<MemberPointerType>()->getPointeeType(); 1625 1626 const llvm::Type *PType = ConvertType(getContext().getPointerType(Ty)); 1627 AddV = Builder.CreateBitCast(AddV, PType); 1628 return LValue::MakeAddr(AddV, MakeQualifiers(Ty)); 1629} 1630 1631