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