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