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