CGExpr.cpp revision 7f2896406c8f14bf123578610043a919ba1a1c8a
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 606static llvm::Value *getBitFieldAddr(LValue LV, CGBuilderTy &Builder) { 607 const CGBitFieldInfo &Info = LV.getBitFieldInfo(); 608 609 llvm::Value *BaseValue = LV.getBitFieldBaseAddr(); 610 const llvm::PointerType *BaseTy = 611 cast<llvm::PointerType>(BaseValue->getType()); 612 613 // Cast to the type of the access we will perform. 614 llvm::Value *V = Builder.CreateBitCast( 615 BaseValue, llvm::PointerType::get(Info.FieldTy, BaseTy->getAddressSpace())); 616 617 // Offset by the access index. 618 return Builder.CreateConstGEP1_32(V, Info.FieldNo); 619} 620 621RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV, 622 QualType ExprType) { 623 const CGBitFieldInfo &Info = LV.getBitFieldInfo(); 624 unsigned StartBit = Info.Start; 625 unsigned BitfieldSize = Info.Size; 626 llvm::Value *Ptr = getBitFieldAddr(LV, Builder); 627 628 const llvm::Type *EltTy = 629 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 630 unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy); 631 632 // In some cases the bitfield may straddle two memory locations. Currently we 633 // load the entire bitfield, then do the magic to sign-extend it if 634 // necessary. This results in somewhat more code than necessary for the common 635 // case (one load), since two shifts accomplish both the masking and sign 636 // extension. 637 unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit); 638 llvm::Value *Val = Builder.CreateLoad(Ptr, LV.isVolatileQualified(), "tmp"); 639 640 // Shift to proper location. 641 if (StartBit) 642 Val = Builder.CreateLShr(Val, StartBit, "bf.lo"); 643 644 // Mask off unused bits. 645 llvm::Constant *LowMask = llvm::ConstantInt::get(VMContext, 646 llvm::APInt::getLowBitsSet(EltTySize, LowBits)); 647 Val = Builder.CreateAnd(Val, LowMask, "bf.lo.cleared"); 648 649 // Fetch the high bits if necessary. 650 if (LowBits < BitfieldSize) { 651 unsigned HighBits = BitfieldSize - LowBits; 652 llvm::Value *HighPtr = Builder.CreateGEP(Ptr, llvm::ConstantInt::get( 653 llvm::Type::getInt32Ty(VMContext), 1), "bf.ptr.hi"); 654 llvm::Value *HighVal = Builder.CreateLoad(HighPtr, 655 LV.isVolatileQualified(), 656 "tmp"); 657 658 // Mask off unused bits. 659 llvm::Constant *HighMask = llvm::ConstantInt::get(VMContext, 660 llvm::APInt::getLowBitsSet(EltTySize, HighBits)); 661 HighVal = Builder.CreateAnd(HighVal, HighMask, "bf.lo.cleared"); 662 663 // Shift to proper location and or in to bitfield value. 664 HighVal = Builder.CreateShl(HighVal, LowBits); 665 Val = Builder.CreateOr(Val, HighVal, "bf.val"); 666 } 667 668 // Sign extend if necessary. 669 if (Info.IsSigned) { 670 llvm::Value *ExtraBits = llvm::ConstantInt::get(EltTy, 671 EltTySize - BitfieldSize); 672 Val = Builder.CreateAShr(Builder.CreateShl(Val, ExtraBits), 673 ExtraBits, "bf.val.sext"); 674 } 675 676 // The bitfield type and the normal type differ when the storage sizes differ 677 // (currently just _Bool). 678 Val = Builder.CreateIntCast(Val, ConvertType(ExprType), false, "tmp"); 679 680 return RValue::get(Val); 681} 682 683RValue CodeGenFunction::EmitLoadOfPropertyRefLValue(LValue LV, 684 QualType ExprType) { 685 return EmitObjCPropertyGet(LV.getPropertyRefExpr()); 686} 687 688RValue CodeGenFunction::EmitLoadOfKVCRefLValue(LValue LV, 689 QualType ExprType) { 690 return EmitObjCPropertyGet(LV.getKVCRefExpr()); 691} 692 693// If this is a reference to a subset of the elements of a vector, create an 694// appropriate shufflevector. 695RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV, 696 QualType ExprType) { 697 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(), 698 LV.isVolatileQualified(), "tmp"); 699 700 const llvm::Constant *Elts = LV.getExtVectorElts(); 701 702 // If the result of the expression is a non-vector type, we must be extracting 703 // a single element. Just codegen as an extractelement. 704 const VectorType *ExprVT = ExprType->getAs<VectorType>(); 705 if (!ExprVT) { 706 unsigned InIdx = getAccessedFieldNo(0, Elts); 707 llvm::Value *Elt = llvm::ConstantInt::get( 708 llvm::Type::getInt32Ty(VMContext), InIdx); 709 return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp")); 710 } 711 712 // Always use shuffle vector to try to retain the original program structure 713 unsigned NumResultElts = ExprVT->getNumElements(); 714 715 llvm::SmallVector<llvm::Constant*, 4> Mask; 716 for (unsigned i = 0; i != NumResultElts; ++i) { 717 unsigned InIdx = getAccessedFieldNo(i, Elts); 718 Mask.push_back(llvm::ConstantInt::get( 719 llvm::Type::getInt32Ty(VMContext), InIdx)); 720 } 721 722 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 723 Vec = Builder.CreateShuffleVector(Vec, 724 llvm::UndefValue::get(Vec->getType()), 725 MaskV, "tmp"); 726 return RValue::get(Vec); 727} 728 729 730 731/// EmitStoreThroughLValue - Store the specified rvalue into the specified 732/// lvalue, where both are guaranteed to the have the same type, and that type 733/// is 'Ty'. 734void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, 735 QualType Ty) { 736 if (!Dst.isSimple()) { 737 if (Dst.isVectorElt()) { 738 // Read/modify/write the vector, inserting the new element. 739 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(), 740 Dst.isVolatileQualified(), "tmp"); 741 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), 742 Dst.getVectorIdx(), "vecins"); 743 Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified()); 744 return; 745 } 746 747 // If this is an update of extended vector elements, insert them as 748 // appropriate. 749 if (Dst.isExtVectorElt()) 750 return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty); 751 752 if (Dst.isBitField()) 753 return EmitStoreThroughBitfieldLValue(Src, Dst, Ty); 754 755 if (Dst.isPropertyRef()) 756 return EmitStoreThroughPropertyRefLValue(Src, Dst, Ty); 757 758 assert(Dst.isKVCRef() && "Unknown LValue type"); 759 return EmitStoreThroughKVCRefLValue(Src, Dst, Ty); 760 } 761 762 if (Dst.isObjCWeak() && !Dst.isNonGC()) { 763 // load of a __weak object. 764 llvm::Value *LvalueDst = Dst.getAddress(); 765 llvm::Value *src = Src.getScalarVal(); 766 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst); 767 return; 768 } 769 770 if (Dst.isObjCStrong() && !Dst.isNonGC()) { 771 // load of a __strong object. 772 llvm::Value *LvalueDst = Dst.getAddress(); 773 llvm::Value *src = Src.getScalarVal(); 774 if (Dst.isObjCIvar()) { 775 assert(Dst.getBaseIvarExp() && "BaseIvarExp is NULL"); 776 const llvm::Type *ResultType = ConvertType(getContext().LongTy); 777 llvm::Value *RHS = EmitScalarExpr(Dst.getBaseIvarExp()); 778 llvm::Value *dst = RHS; 779 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 780 llvm::Value *LHS = 781 Builder.CreatePtrToInt(LvalueDst, ResultType, "sub.ptr.lhs.cast"); 782 llvm::Value *BytesBetween = Builder.CreateSub(LHS, RHS, "ivar.offset"); 783 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, dst, 784 BytesBetween); 785 } else if (Dst.isGlobalObjCRef()) 786 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst); 787 else 788 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst); 789 return; 790 } 791 792 assert(Src.isScalar() && "Can't emit an agg store with this method"); 793 EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(), 794 Dst.isVolatileQualified(), Ty); 795} 796 797void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 798 QualType Ty, 799 llvm::Value **Result) { 800 const CGBitFieldInfo &Info = Dst.getBitFieldInfo(); 801 unsigned StartBit = Info.Start; 802 unsigned BitfieldSize = Info.Size; 803 llvm::Value *Ptr = getBitFieldAddr(Dst, Builder); 804 805 const llvm::Type *EltTy = 806 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 807 unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy); 808 809 // Get the new value, cast to the appropriate type and masked to exactly the 810 // size of the bit-field. 811 llvm::Value *SrcVal = Src.getScalarVal(); 812 llvm::Value *NewVal = Builder.CreateIntCast(SrcVal, EltTy, false, "tmp"); 813 llvm::Constant *Mask = llvm::ConstantInt::get(VMContext, 814 llvm::APInt::getLowBitsSet(EltTySize, BitfieldSize)); 815 NewVal = Builder.CreateAnd(NewVal, Mask, "bf.value"); 816 817 // Return the new value of the bit-field, if requested. 818 if (Result) { 819 // Cast back to the proper type for result. 820 const llvm::Type *SrcTy = SrcVal->getType(); 821 llvm::Value *SrcTrunc = Builder.CreateIntCast(NewVal, SrcTy, false, 822 "bf.reload.val"); 823 824 // Sign extend if necessary. 825 if (Info.IsSigned) { 826 unsigned SrcTySize = CGM.getTargetData().getTypeSizeInBits(SrcTy); 827 llvm::Value *ExtraBits = llvm::ConstantInt::get(SrcTy, 828 SrcTySize - BitfieldSize); 829 SrcTrunc = Builder.CreateAShr(Builder.CreateShl(SrcTrunc, ExtraBits), 830 ExtraBits, "bf.reload.sext"); 831 } 832 833 *Result = SrcTrunc; 834 } 835 836 // In some cases the bitfield may straddle two memory locations. Emit the low 837 // part first and check to see if the high needs to be done. 838 unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit); 839 llvm::Value *LowVal = Builder.CreateLoad(Ptr, Dst.isVolatileQualified(), 840 "bf.prev.low"); 841 842 // Compute the mask for zero-ing the low part of this bitfield. 843 llvm::Constant *InvMask = 844 llvm::ConstantInt::get(VMContext, 845 ~llvm::APInt::getBitsSet(EltTySize, StartBit, StartBit + LowBits)); 846 847 // Compute the new low part as 848 // LowVal = (LowVal & InvMask) | (NewVal << StartBit), 849 // with the shift of NewVal implicitly stripping the high bits. 850 llvm::Value *NewLowVal = 851 Builder.CreateShl(NewVal, StartBit, "bf.value.lo"); 852 LowVal = Builder.CreateAnd(LowVal, InvMask, "bf.prev.lo.cleared"); 853 LowVal = Builder.CreateOr(LowVal, NewLowVal, "bf.new.lo"); 854 855 // Write back. 856 Builder.CreateStore(LowVal, Ptr, Dst.isVolatileQualified()); 857 858 // If the low part doesn't cover the bitfield emit a high part. 859 if (LowBits < BitfieldSize) { 860 unsigned HighBits = BitfieldSize - LowBits; 861 llvm::Value *HighPtr = Builder.CreateGEP(Ptr, llvm::ConstantInt::get( 862 llvm::Type::getInt32Ty(VMContext), 1), "bf.ptr.hi"); 863 llvm::Value *HighVal = Builder.CreateLoad(HighPtr, 864 Dst.isVolatileQualified(), 865 "bf.prev.hi"); 866 867 // Compute the mask for zero-ing the high part of this bitfield. 868 llvm::Constant *InvMask = 869 llvm::ConstantInt::get(VMContext, ~llvm::APInt::getLowBitsSet(EltTySize, 870 HighBits)); 871 872 // Compute the new high part as 873 // HighVal = (HighVal & InvMask) | (NewVal lshr LowBits), 874 // where the high bits of NewVal have already been cleared and the 875 // shift stripping the low bits. 876 llvm::Value *NewHighVal = 877 Builder.CreateLShr(NewVal, LowBits, "bf.value.high"); 878 HighVal = Builder.CreateAnd(HighVal, InvMask, "bf.prev.hi.cleared"); 879 HighVal = Builder.CreateOr(HighVal, NewHighVal, "bf.new.hi"); 880 881 // Write back. 882 Builder.CreateStore(HighVal, HighPtr, Dst.isVolatileQualified()); 883 } 884} 885 886void CodeGenFunction::EmitStoreThroughPropertyRefLValue(RValue Src, 887 LValue Dst, 888 QualType Ty) { 889 EmitObjCPropertySet(Dst.getPropertyRefExpr(), Src); 890} 891 892void CodeGenFunction::EmitStoreThroughKVCRefLValue(RValue Src, 893 LValue Dst, 894 QualType Ty) { 895 EmitObjCPropertySet(Dst.getKVCRefExpr(), Src); 896} 897 898void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, 899 LValue Dst, 900 QualType Ty) { 901 // This access turns into a read/modify/write of the vector. Load the input 902 // value now. 903 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(), 904 Dst.isVolatileQualified(), "tmp"); 905 const llvm::Constant *Elts = Dst.getExtVectorElts(); 906 907 llvm::Value *SrcVal = Src.getScalarVal(); 908 909 if (const VectorType *VTy = Ty->getAs<VectorType>()) { 910 unsigned NumSrcElts = VTy->getNumElements(); 911 unsigned NumDstElts = 912 cast<llvm::VectorType>(Vec->getType())->getNumElements(); 913 if (NumDstElts == NumSrcElts) { 914 // Use shuffle vector is the src and destination are the same number of 915 // elements and restore the vector mask since it is on the side it will be 916 // stored. 917 llvm::SmallVector<llvm::Constant*, 4> Mask(NumDstElts); 918 for (unsigned i = 0; i != NumSrcElts; ++i) { 919 unsigned InIdx = getAccessedFieldNo(i, Elts); 920 Mask[InIdx] = llvm::ConstantInt::get( 921 llvm::Type::getInt32Ty(VMContext), i); 922 } 923 924 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 925 Vec = Builder.CreateShuffleVector(SrcVal, 926 llvm::UndefValue::get(Vec->getType()), 927 MaskV, "tmp"); 928 } else if (NumDstElts > NumSrcElts) { 929 // Extended the source vector to the same length and then shuffle it 930 // into the destination. 931 // FIXME: since we're shuffling with undef, can we just use the indices 932 // into that? This could be simpler. 933 llvm::SmallVector<llvm::Constant*, 4> ExtMask; 934 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext); 935 unsigned i; 936 for (i = 0; i != NumSrcElts; ++i) 937 ExtMask.push_back(llvm::ConstantInt::get(Int32Ty, i)); 938 for (; i != NumDstElts; ++i) 939 ExtMask.push_back(llvm::UndefValue::get(Int32Ty)); 940 llvm::Value *ExtMaskV = llvm::ConstantVector::get(&ExtMask[0], 941 ExtMask.size()); 942 llvm::Value *ExtSrcVal = 943 Builder.CreateShuffleVector(SrcVal, 944 llvm::UndefValue::get(SrcVal->getType()), 945 ExtMaskV, "tmp"); 946 // build identity 947 llvm::SmallVector<llvm::Constant*, 4> Mask; 948 for (unsigned i = 0; i != NumDstElts; ++i) 949 Mask.push_back(llvm::ConstantInt::get(Int32Ty, i)); 950 951 // modify when what gets shuffled in 952 for (unsigned i = 0; i != NumSrcElts; ++i) { 953 unsigned Idx = getAccessedFieldNo(i, Elts); 954 Mask[Idx] = llvm::ConstantInt::get(Int32Ty, i+NumDstElts); 955 } 956 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 957 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp"); 958 } else { 959 // We should never shorten the vector 960 assert(0 && "unexpected shorten vector length"); 961 } 962 } else { 963 // If the Src is a scalar (not a vector) it must be updating one element. 964 unsigned InIdx = getAccessedFieldNo(0, Elts); 965 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext); 966 llvm::Value *Elt = llvm::ConstantInt::get(Int32Ty, InIdx); 967 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp"); 968 } 969 970 Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified()); 971} 972 973// setObjCGCLValueClass - sets class of he lvalue for the purpose of 974// generating write-barries API. It is currently a global, ivar, 975// or neither. 976static void setObjCGCLValueClass(const ASTContext &Ctx, const Expr *E, 977 LValue &LV) { 978 if (Ctx.getLangOptions().getGCMode() == LangOptions::NonGC) 979 return; 980 981 if (isa<ObjCIvarRefExpr>(E)) { 982 LV.SetObjCIvar(LV, true); 983 ObjCIvarRefExpr *Exp = cast<ObjCIvarRefExpr>(const_cast<Expr*>(E)); 984 LV.setBaseIvarExp(Exp->getBase()); 985 LV.SetObjCArray(LV, E->getType()->isArrayType()); 986 return; 987 } 988 989 if (const DeclRefExpr *Exp = dyn_cast<DeclRefExpr>(E)) { 990 if (const VarDecl *VD = dyn_cast<VarDecl>(Exp->getDecl())) { 991 if ((VD->isBlockVarDecl() && !VD->hasLocalStorage()) || 992 VD->isFileVarDecl()) 993 LV.SetGlobalObjCRef(LV, true); 994 } 995 LV.SetObjCArray(LV, E->getType()->isArrayType()); 996 return; 997 } 998 999 if (const UnaryOperator *Exp = dyn_cast<UnaryOperator>(E)) { 1000 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1001 return; 1002 } 1003 1004 if (const ParenExpr *Exp = dyn_cast<ParenExpr>(E)) { 1005 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1006 if (LV.isObjCIvar()) { 1007 // If cast is to a structure pointer, follow gcc's behavior and make it 1008 // a non-ivar write-barrier. 1009 QualType ExpTy = E->getType(); 1010 if (ExpTy->isPointerType()) 1011 ExpTy = ExpTy->getAs<PointerType>()->getPointeeType(); 1012 if (ExpTy->isRecordType()) 1013 LV.SetObjCIvar(LV, false); 1014 } 1015 return; 1016 } 1017 if (const ImplicitCastExpr *Exp = dyn_cast<ImplicitCastExpr>(E)) { 1018 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1019 return; 1020 } 1021 1022 if (const CStyleCastExpr *Exp = dyn_cast<CStyleCastExpr>(E)) { 1023 setObjCGCLValueClass(Ctx, Exp->getSubExpr(), LV); 1024 return; 1025 } 1026 1027 if (const ArraySubscriptExpr *Exp = dyn_cast<ArraySubscriptExpr>(E)) { 1028 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 1029 if (LV.isObjCIvar() && !LV.isObjCArray()) 1030 // Using array syntax to assigning to what an ivar points to is not 1031 // same as assigning to the ivar itself. {id *Names;} Names[i] = 0; 1032 LV.SetObjCIvar(LV, false); 1033 else if (LV.isGlobalObjCRef() && !LV.isObjCArray()) 1034 // Using array syntax to assigning to what global points to is not 1035 // same as assigning to the global itself. {id *G;} G[i] = 0; 1036 LV.SetGlobalObjCRef(LV, false); 1037 return; 1038 } 1039 1040 if (const MemberExpr *Exp = dyn_cast<MemberExpr>(E)) { 1041 setObjCGCLValueClass(Ctx, Exp->getBase(), LV); 1042 // We don't know if member is an 'ivar', but this flag is looked at 1043 // only in the context of LV.isObjCIvar(). 1044 LV.SetObjCArray(LV, E->getType()->isArrayType()); 1045 return; 1046 } 1047} 1048 1049static LValue EmitGlobalVarDeclLValue(CodeGenFunction &CGF, 1050 const Expr *E, const VarDecl *VD) { 1051 assert((VD->hasExternalStorage() || VD->isFileVarDecl()) && 1052 "Var decl must have external storage or be a file var decl!"); 1053 1054 llvm::Value *V = CGF.CGM.GetAddrOfGlobalVar(VD); 1055 if (VD->getType()->isReferenceType()) 1056 V = CGF.Builder.CreateLoad(V, "tmp"); 1057 LValue LV = LValue::MakeAddr(V, CGF.MakeQualifiers(E->getType())); 1058 setObjCGCLValueClass(CGF.getContext(), E, LV); 1059 return LV; 1060} 1061 1062static LValue EmitFunctionDeclLValue(CodeGenFunction &CGF, 1063 const Expr *E, const FunctionDecl *FD) { 1064 llvm::Value* V = CGF.CGM.GetAddrOfFunction(FD); 1065 if (!FD->hasPrototype()) { 1066 if (const FunctionProtoType *Proto = 1067 FD->getType()->getAs<FunctionProtoType>()) { 1068 // Ugly case: for a K&R-style definition, the type of the definition 1069 // isn't the same as the type of a use. Correct for this with a 1070 // bitcast. 1071 QualType NoProtoType = 1072 CGF.getContext().getFunctionNoProtoType(Proto->getResultType()); 1073 NoProtoType = CGF.getContext().getPointerType(NoProtoType); 1074 V = CGF.Builder.CreateBitCast(V, CGF.ConvertType(NoProtoType), "tmp"); 1075 } 1076 } 1077 return LValue::MakeAddr(V, CGF.MakeQualifiers(E->getType())); 1078} 1079 1080LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { 1081 const NamedDecl *ND = E->getDecl(); 1082 1083 if (ND->hasAttr<WeakRefAttr>()) { 1084 const ValueDecl* VD = cast<ValueDecl>(ND); 1085 llvm::Constant *Aliasee = CGM.GetWeakRefReference(VD); 1086 1087 Qualifiers Quals = MakeQualifiers(E->getType()); 1088 LValue LV = LValue::MakeAddr(Aliasee, Quals); 1089 1090 return LV; 1091 } 1092 1093 if (const VarDecl *VD = dyn_cast<VarDecl>(ND)) { 1094 1095 // Check if this is a global variable. 1096 if (VD->hasExternalStorage() || VD->isFileVarDecl()) 1097 return EmitGlobalVarDeclLValue(*this, E, VD); 1098 1099 bool NonGCable = VD->hasLocalStorage() && !VD->hasAttr<BlocksAttr>(); 1100 1101 llvm::Value *V = LocalDeclMap[VD]; 1102 assert(V && "DeclRefExpr not entered in LocalDeclMap?"); 1103 1104 Qualifiers Quals = MakeQualifiers(E->getType()); 1105 // local variables do not get their gc attribute set. 1106 // local static? 1107 if (NonGCable) Quals.removeObjCGCAttr(); 1108 1109 if (VD->hasAttr<BlocksAttr>()) { 1110 V = Builder.CreateStructGEP(V, 1, "forwarding"); 1111 V = Builder.CreateLoad(V); 1112 V = Builder.CreateStructGEP(V, getByRefValueLLVMField(VD), 1113 VD->getNameAsString()); 1114 } 1115 if (VD->getType()->isReferenceType()) 1116 V = Builder.CreateLoad(V, "tmp"); 1117 LValue LV = LValue::MakeAddr(V, Quals); 1118 LValue::SetObjCNonGC(LV, NonGCable); 1119 setObjCGCLValueClass(getContext(), E, LV); 1120 return LV; 1121 } 1122 1123 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) 1124 return EmitFunctionDeclLValue(*this, E, FD); 1125 1126 // FIXME: the qualifier check does not seem sufficient here 1127 if (E->getQualifier()) { 1128 const FieldDecl *FD = cast<FieldDecl>(ND); 1129 llvm::Value *V = CGM.EmitPointerToDataMember(FD); 1130 1131 return LValue::MakeAddr(V, MakeQualifiers(FD->getType())); 1132 } 1133 1134 assert(false && "Unhandled DeclRefExpr"); 1135 1136 // an invalid LValue, but the assert will 1137 // ensure that this point is never reached. 1138 return LValue(); 1139} 1140 1141LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) { 1142 return LValue::MakeAddr(GetAddrOfBlockDecl(E), MakeQualifiers(E->getType())); 1143} 1144 1145LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { 1146 // __extension__ doesn't affect lvalue-ness. 1147 if (E->getOpcode() == UnaryOperator::Extension) 1148 return EmitLValue(E->getSubExpr()); 1149 1150 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType()); 1151 switch (E->getOpcode()) { 1152 default: assert(0 && "Unknown unary operator lvalue!"); 1153 case UnaryOperator::Deref: { 1154 QualType T = E->getSubExpr()->getType()->getPointeeType(); 1155 assert(!T.isNull() && "CodeGenFunction::EmitUnaryOpLValue: Illegal type"); 1156 1157 Qualifiers Quals = MakeQualifiers(T); 1158 Quals.setAddressSpace(ExprTy.getAddressSpace()); 1159 1160 LValue LV = LValue::MakeAddr(EmitScalarExpr(E->getSubExpr()), Quals); 1161 // We should not generate __weak write barrier on indirect reference 1162 // of a pointer to object; as in void foo (__weak id *param); *param = 0; 1163 // But, we continue to generate __strong write barrier on indirect write 1164 // into a pointer to object. 1165 if (getContext().getLangOptions().ObjC1 && 1166 getContext().getLangOptions().getGCMode() != LangOptions::NonGC && 1167 LV.isObjCWeak()) 1168 LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate(getContext())); 1169 return LV; 1170 } 1171 case UnaryOperator::Real: 1172 case UnaryOperator::Imag: { 1173 LValue LV = EmitLValue(E->getSubExpr()); 1174 unsigned Idx = E->getOpcode() == UnaryOperator::Imag; 1175 return LValue::MakeAddr(Builder.CreateStructGEP(LV.getAddress(), 1176 Idx, "idx"), 1177 MakeQualifiers(ExprTy)); 1178 } 1179 case UnaryOperator::PreInc: 1180 case UnaryOperator::PreDec: { 1181 LValue LV = EmitLValue(E->getSubExpr()); 1182 bool isInc = E->getOpcode() == UnaryOperator::PreInc; 1183 1184 if (E->getType()->isAnyComplexType()) 1185 EmitComplexPrePostIncDec(E, LV, isInc, true/*isPre*/); 1186 else 1187 EmitScalarPrePostIncDec(E, LV, isInc, true/*isPre*/); 1188 return LV; 1189 } 1190 } 1191} 1192 1193LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { 1194 return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromLiteral(E), 1195 Qualifiers()); 1196} 1197 1198LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) { 1199 return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromObjCEncode(E), 1200 Qualifiers()); 1201} 1202 1203 1204LValue CodeGenFunction::EmitPredefinedFunctionName(unsigned Type) { 1205 std::string GlobalVarName; 1206 1207 switch (Type) { 1208 default: assert(0 && "Invalid type"); 1209 case PredefinedExpr::Func: 1210 GlobalVarName = "__func__."; 1211 break; 1212 case PredefinedExpr::Function: 1213 GlobalVarName = "__FUNCTION__."; 1214 break; 1215 case PredefinedExpr::PrettyFunction: 1216 GlobalVarName = "__PRETTY_FUNCTION__."; 1217 break; 1218 } 1219 1220 llvm::StringRef FnName = CurFn->getName(); 1221 if (FnName.startswith("\01")) 1222 FnName = FnName.substr(1); 1223 GlobalVarName += FnName; 1224 1225 std::string FunctionName = 1226 PredefinedExpr::ComputeName((PredefinedExpr::IdentType)Type, CurCodeDecl); 1227 1228 llvm::Constant *C = 1229 CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str()); 1230 return LValue::MakeAddr(C, Qualifiers()); 1231} 1232 1233LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { 1234 switch (E->getIdentType()) { 1235 default: 1236 return EmitUnsupportedLValue(E, "predefined expression"); 1237 case PredefinedExpr::Func: 1238 case PredefinedExpr::Function: 1239 case PredefinedExpr::PrettyFunction: 1240 return EmitPredefinedFunctionName(E->getIdentType()); 1241 } 1242} 1243 1244llvm::BasicBlock *CodeGenFunction::getTrapBB() { 1245 const CodeGenOptions &GCO = CGM.getCodeGenOpts(); 1246 1247 // If we are not optimzing, don't collapse all calls to trap in the function 1248 // to the same call, that way, in the debugger they can see which operation 1249 // did in fact fail. If we are optimizing, we collpase all call to trap down 1250 // to just one per function to save on codesize. 1251 if (GCO.OptimizationLevel 1252 && TrapBB) 1253 return TrapBB; 1254 1255 llvm::BasicBlock *Cont = 0; 1256 if (HaveInsertPoint()) { 1257 Cont = createBasicBlock("cont"); 1258 EmitBranch(Cont); 1259 } 1260 TrapBB = createBasicBlock("trap"); 1261 EmitBlock(TrapBB); 1262 1263 llvm::Value *F = CGM.getIntrinsic(llvm::Intrinsic::trap, 0, 0); 1264 llvm::CallInst *TrapCall = Builder.CreateCall(F); 1265 TrapCall->setDoesNotReturn(); 1266 TrapCall->setDoesNotThrow(); 1267 Builder.CreateUnreachable(); 1268 1269 if (Cont) 1270 EmitBlock(Cont); 1271 return TrapBB; 1272} 1273 1274LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { 1275 // The index must always be an integer, which is not an aggregate. Emit it. 1276 llvm::Value *Idx = EmitScalarExpr(E->getIdx()); 1277 QualType IdxTy = E->getIdx()->getType(); 1278 bool IdxSigned = IdxTy->isSignedIntegerType(); 1279 1280 // If the base is a vector type, then we are forming a vector element lvalue 1281 // with this subscript. 1282 if (E->getBase()->getType()->isVectorType()) { 1283 // Emit the vector as an lvalue to get its address. 1284 LValue LHS = EmitLValue(E->getBase()); 1285 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 1286 Idx = Builder.CreateIntCast(Idx, 1287 llvm::Type::getInt32Ty(VMContext), IdxSigned, "vidx"); 1288 return LValue::MakeVectorElt(LHS.getAddress(), Idx, 1289 E->getBase()->getType().getCVRQualifiers()); 1290 } 1291 1292 // The base must be a pointer, which is not an aggregate. Emit it. 1293 llvm::Value *Base = EmitScalarExpr(E->getBase()); 1294 1295 // Extend or truncate the index type to 32 or 64-bits. 1296 unsigned IdxBitwidth = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 1297 if (IdxBitwidth != LLVMPointerWidth) 1298 Idx = Builder.CreateIntCast(Idx, 1299 llvm::IntegerType::get(VMContext, LLVMPointerWidth), 1300 IdxSigned, "idxprom"); 1301 1302 // FIXME: As llvm implements the object size checking, this can come out. 1303 if (CatchUndefined) { 1304 if (const ImplicitCastExpr *ICE=dyn_cast<ImplicitCastExpr>(E->getBase())) { 1305 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(ICE->getSubExpr())) { 1306 if (ICE->getCastKind() == CastExpr::CK_ArrayToPointerDecay) { 1307 if (const ConstantArrayType *CAT 1308 = getContext().getAsConstantArrayType(DRE->getType())) { 1309 llvm::APInt Size = CAT->getSize(); 1310 llvm::BasicBlock *Cont = createBasicBlock("cont"); 1311 Builder.CreateCondBr(Builder.CreateICmpULE(Idx, 1312 llvm::ConstantInt::get(Idx->getType(), Size)), 1313 Cont, getTrapBB()); 1314 EmitBlock(Cont); 1315 } 1316 } 1317 } 1318 } 1319 } 1320 1321 // We know that the pointer points to a type of the correct size, unless the 1322 // size is a VLA or Objective-C interface. 1323 llvm::Value *Address = 0; 1324 if (const VariableArrayType *VAT = 1325 getContext().getAsVariableArrayType(E->getType())) { 1326 llvm::Value *VLASize = GetVLASize(VAT); 1327 1328 Idx = Builder.CreateMul(Idx, VLASize); 1329 1330 QualType BaseType = getContext().getBaseElementType(VAT); 1331 1332 CharUnits BaseTypeSize = getContext().getTypeSizeInChars(BaseType); 1333 Idx = Builder.CreateUDiv(Idx, 1334 llvm::ConstantInt::get(Idx->getType(), 1335 BaseTypeSize.getQuantity())); 1336 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx"); 1337 } else if (const ObjCInterfaceType *OIT = 1338 dyn_cast<ObjCInterfaceType>(E->getType())) { 1339 llvm::Value *InterfaceSize = 1340 llvm::ConstantInt::get(Idx->getType(), 1341 getContext().getTypeSizeInChars(OIT).getQuantity()); 1342 1343 Idx = Builder.CreateMul(Idx, InterfaceSize); 1344 1345 const llvm::Type *i8PTy = llvm::Type::getInt8PtrTy(VMContext); 1346 Address = Builder.CreateGEP(Builder.CreateBitCast(Base, i8PTy), 1347 Idx, "arrayidx"); 1348 Address = Builder.CreateBitCast(Address, Base->getType()); 1349 } else { 1350 Address = Builder.CreateInBoundsGEP(Base, Idx, "arrayidx"); 1351 } 1352 1353 QualType T = E->getBase()->getType()->getPointeeType(); 1354 assert(!T.isNull() && 1355 "CodeGenFunction::EmitArraySubscriptExpr(): Illegal base type"); 1356 1357 Qualifiers Quals = MakeQualifiers(T); 1358 Quals.setAddressSpace(E->getBase()->getType().getAddressSpace()); 1359 1360 LValue LV = LValue::MakeAddr(Address, Quals); 1361 if (getContext().getLangOptions().ObjC1 && 1362 getContext().getLangOptions().getGCMode() != LangOptions::NonGC) { 1363 LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate(getContext())); 1364 setObjCGCLValueClass(getContext(), E, LV); 1365 } 1366 return LV; 1367} 1368 1369static 1370llvm::Constant *GenerateConstantVector(llvm::LLVMContext &VMContext, 1371 llvm::SmallVector<unsigned, 4> &Elts) { 1372 llvm::SmallVector<llvm::Constant*, 4> CElts; 1373 1374 for (unsigned i = 0, e = Elts.size(); i != e; ++i) 1375 CElts.push_back(llvm::ConstantInt::get( 1376 llvm::Type::getInt32Ty(VMContext), Elts[i])); 1377 1378 return llvm::ConstantVector::get(&CElts[0], CElts.size()); 1379} 1380 1381LValue CodeGenFunction:: 1382EmitExtVectorElementExpr(const ExtVectorElementExpr *E) { 1383 const llvm::Type *Int32Ty = llvm::Type::getInt32Ty(VMContext); 1384 1385 // Emit the base vector as an l-value. 1386 LValue Base; 1387 1388 // ExtVectorElementExpr's base can either be a vector or pointer to vector. 1389 if (E->isArrow()) { 1390 // If it is a pointer to a vector, emit the address and form an lvalue with 1391 // it. 1392 llvm::Value *Ptr = EmitScalarExpr(E->getBase()); 1393 const PointerType *PT = E->getBase()->getType()->getAs<PointerType>(); 1394 Qualifiers Quals = MakeQualifiers(PT->getPointeeType()); 1395 Quals.removeObjCGCAttr(); 1396 Base = LValue::MakeAddr(Ptr, Quals); 1397 } else if (E->getBase()->isLvalue(getContext()) == Expr::LV_Valid) { 1398 // Otherwise, if the base is an lvalue ( as in the case of foo.x.x), 1399 // emit the base as an lvalue. 1400 assert(E->getBase()->getType()->isVectorType()); 1401 Base = EmitLValue(E->getBase()); 1402 } else { 1403 // Otherwise, the base is a normal rvalue (as in (V+V).x), emit it as such. 1404 assert(E->getBase()->getType()->getAs<VectorType>() && 1405 "Result must be a vector"); 1406 llvm::Value *Vec = EmitScalarExpr(E->getBase()); 1407 1408 // Store the vector to memory (because LValue wants an address). 1409 llvm::Value *VecMem = CreateMemTemp(E->getBase()->getType()); 1410 Builder.CreateStore(Vec, VecMem); 1411 Base = LValue::MakeAddr(VecMem, Qualifiers()); 1412 } 1413 1414 // Encode the element access list into a vector of unsigned indices. 1415 llvm::SmallVector<unsigned, 4> Indices; 1416 E->getEncodedElementAccess(Indices); 1417 1418 if (Base.isSimple()) { 1419 llvm::Constant *CV = GenerateConstantVector(VMContext, Indices); 1420 return LValue::MakeExtVectorElt(Base.getAddress(), CV, 1421 Base.getVRQualifiers()); 1422 } 1423 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!"); 1424 1425 llvm::Constant *BaseElts = Base.getExtVectorElts(); 1426 llvm::SmallVector<llvm::Constant *, 4> CElts; 1427 1428 for (unsigned i = 0, e = Indices.size(); i != e; ++i) { 1429 if (isa<llvm::ConstantAggregateZero>(BaseElts)) 1430 CElts.push_back(llvm::ConstantInt::get(Int32Ty, 0)); 1431 else 1432 CElts.push_back(cast<llvm::Constant>(BaseElts->getOperand(Indices[i]))); 1433 } 1434 llvm::Constant *CV = llvm::ConstantVector::get(&CElts[0], CElts.size()); 1435 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, 1436 Base.getVRQualifiers()); 1437} 1438 1439LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { 1440 bool isNonGC = false; 1441 Expr *BaseExpr = E->getBase(); 1442 llvm::Value *BaseValue = NULL; 1443 Qualifiers BaseQuals; 1444 1445 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 1446 if (E->isArrow()) { 1447 BaseValue = EmitScalarExpr(BaseExpr); 1448 const PointerType *PTy = 1449 BaseExpr->getType()->getAs<PointerType>(); 1450 BaseQuals = PTy->getPointeeType().getQualifiers(); 1451 } else if (isa<ObjCPropertyRefExpr>(BaseExpr->IgnoreParens()) || 1452 isa<ObjCImplicitSetterGetterRefExpr>( 1453 BaseExpr->IgnoreParens())) { 1454 RValue RV = EmitObjCPropertyGet(BaseExpr); 1455 BaseValue = RV.getAggregateAddr(); 1456 BaseQuals = BaseExpr->getType().getQualifiers(); 1457 } else { 1458 LValue BaseLV = EmitLValue(BaseExpr); 1459 if (BaseLV.isNonGC()) 1460 isNonGC = true; 1461 // FIXME: this isn't right for bitfields. 1462 BaseValue = BaseLV.getAddress(); 1463 QualType BaseTy = BaseExpr->getType(); 1464 BaseQuals = BaseTy.getQualifiers(); 1465 } 1466 1467 NamedDecl *ND = E->getMemberDecl(); 1468 if (FieldDecl *Field = dyn_cast<FieldDecl>(ND)) { 1469 LValue LV = EmitLValueForField(BaseValue, Field, 1470 BaseQuals.getCVRQualifiers()); 1471 LValue::SetObjCNonGC(LV, isNonGC); 1472 setObjCGCLValueClass(getContext(), E, LV); 1473 return LV; 1474 } 1475 1476 if (VarDecl *VD = dyn_cast<VarDecl>(ND)) 1477 return EmitGlobalVarDeclLValue(*this, E, VD); 1478 1479 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(ND)) 1480 return EmitFunctionDeclLValue(*this, E, FD); 1481 1482 assert(false && "Unhandled member declaration!"); 1483 return LValue(); 1484} 1485 1486LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value* BaseValue, 1487 const FieldDecl* Field, 1488 unsigned CVRQualifiers) { 1489 const CGRecordLayout &RL = 1490 CGM.getTypes().getCGRecordLayout(Field->getParent()); 1491 const CGBitFieldInfo &Info = RL.getBitFieldInfo(Field); 1492 return LValue::MakeBitfield(BaseValue, Info, 1493 Field->getType().getCVRQualifiers()|CVRQualifiers); 1494} 1495 1496LValue CodeGenFunction::EmitLValueForField(llvm::Value* BaseValue, 1497 const FieldDecl* Field, 1498 unsigned CVRQualifiers) { 1499 if (Field->isBitField()) 1500 return EmitLValueForBitfield(BaseValue, Field, CVRQualifiers); 1501 1502 const CGRecordLayout &RL = 1503 CGM.getTypes().getCGRecordLayout(Field->getParent()); 1504 unsigned idx = RL.getLLVMFieldNo(Field); 1505 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp"); 1506 1507 // Match union field type. 1508 if (Field->getParent()->isUnion()) { 1509 const llvm::Type *FieldTy = 1510 CGM.getTypes().ConvertTypeForMem(Field->getType()); 1511 const llvm::PointerType * BaseTy = 1512 cast<llvm::PointerType>(BaseValue->getType()); 1513 unsigned AS = BaseTy->getAddressSpace(); 1514 V = Builder.CreateBitCast(V, 1515 llvm::PointerType::get(FieldTy, AS), 1516 "tmp"); 1517 } 1518 if (Field->getType()->isReferenceType()) 1519 V = Builder.CreateLoad(V, "tmp"); 1520 1521 Qualifiers Quals = MakeQualifiers(Field->getType()); 1522 Quals.addCVRQualifiers(CVRQualifiers); 1523 // __weak attribute on a field is ignored. 1524 if (Quals.getObjCGCAttr() == Qualifiers::Weak) 1525 Quals.removeObjCGCAttr(); 1526 1527 return LValue::MakeAddr(V, Quals); 1528} 1529 1530LValue 1531CodeGenFunction::EmitLValueForFieldInitialization(llvm::Value* BaseValue, 1532 const FieldDecl* Field, 1533 unsigned CVRQualifiers) { 1534 QualType FieldType = Field->getType(); 1535 1536 if (!FieldType->isReferenceType()) 1537 return EmitLValueForField(BaseValue, Field, CVRQualifiers); 1538 1539 const CGRecordLayout &RL = 1540 CGM.getTypes().getCGRecordLayout(Field->getParent()); 1541 unsigned idx = RL.getLLVMFieldNo(Field); 1542 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp"); 1543 1544 assert(!FieldType.getObjCGCAttr() && "fields cannot have GC attrs"); 1545 1546 return LValue::MakeAddr(V, MakeQualifiers(FieldType)); 1547} 1548 1549LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr* E){ 1550 llvm::Value *DeclPtr = CreateMemTemp(E->getType(), ".compoundliteral"); 1551 const Expr* InitExpr = E->getInitializer(); 1552 LValue Result = LValue::MakeAddr(DeclPtr, MakeQualifiers(E->getType())); 1553 1554 if (E->getType()->isComplexType()) 1555 EmitComplexExprIntoAddr(InitExpr, DeclPtr, false); 1556 else if (hasAggregateLLVMType(E->getType())) 1557 EmitAnyExpr(InitExpr, DeclPtr, false); 1558 else 1559 EmitStoreThroughLValue(EmitAnyExpr(InitExpr), Result, E->getType()); 1560 1561 return Result; 1562} 1563 1564LValue 1565CodeGenFunction::EmitConditionalOperatorLValue(const ConditionalOperator* E) { 1566 if (E->isLvalue(getContext()) == Expr::LV_Valid) { 1567 if (int Cond = ConstantFoldsToSimpleInteger(E->getCond())) { 1568 Expr *Live = Cond == 1 ? E->getLHS() : E->getRHS(); 1569 if (Live) 1570 return EmitLValue(Live); 1571 } 1572 1573 if (!E->getLHS()) 1574 return EmitUnsupportedLValue(E, "conditional operator with missing LHS"); 1575 1576 llvm::BasicBlock *LHSBlock = createBasicBlock("cond.true"); 1577 llvm::BasicBlock *RHSBlock = createBasicBlock("cond.false"); 1578 llvm::BasicBlock *ContBlock = createBasicBlock("cond.end"); 1579 1580 EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 1581 1582 // Any temporaries created here are conditional. 1583 BeginConditionalBranch(); 1584 EmitBlock(LHSBlock); 1585 LValue LHS = EmitLValue(E->getLHS()); 1586 EndConditionalBranch(); 1587 1588 if (!LHS.isSimple()) 1589 return EmitUnsupportedLValue(E, "conditional operator"); 1590 1591 // FIXME: We shouldn't need an alloca for this. 1592 llvm::Value *Temp = CreateTempAlloca(LHS.getAddress()->getType(),"condtmp"); 1593 Builder.CreateStore(LHS.getAddress(), Temp); 1594 EmitBranch(ContBlock); 1595 1596 // Any temporaries created here are conditional. 1597 BeginConditionalBranch(); 1598 EmitBlock(RHSBlock); 1599 LValue RHS = EmitLValue(E->getRHS()); 1600 EndConditionalBranch(); 1601 if (!RHS.isSimple()) 1602 return EmitUnsupportedLValue(E, "conditional operator"); 1603 1604 Builder.CreateStore(RHS.getAddress(), Temp); 1605 EmitBranch(ContBlock); 1606 1607 EmitBlock(ContBlock); 1608 1609 Temp = Builder.CreateLoad(Temp, "lv"); 1610 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1611 } 1612 1613 // ?: here should be an aggregate. 1614 assert((hasAggregateLLVMType(E->getType()) && 1615 !E->getType()->isAnyComplexType()) && 1616 "Unexpected conditional operator!"); 1617 1618 return EmitAggExprToLValue(E); 1619} 1620 1621/// EmitCastLValue - Casts are never lvalues unless that cast is a dynamic_cast. 1622/// If the cast is a dynamic_cast, we can have the usual lvalue result, 1623/// otherwise if a cast is needed by the code generator in an lvalue context, 1624/// then it must mean that we need the address of an aggregate in order to 1625/// access one of its fields. This can happen for all the reasons that casts 1626/// are permitted with aggregate result, including noop aggregate casts, and 1627/// cast from scalar to union. 1628LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { 1629 switch (E->getCastKind()) { 1630 default: 1631 return EmitUnsupportedLValue(E, "unexpected cast lvalue"); 1632 1633 case CastExpr::CK_Dynamic: { 1634 LValue LV = EmitLValue(E->getSubExpr()); 1635 llvm::Value *V = LV.getAddress(); 1636 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(E); 1637 return LValue::MakeAddr(EmitDynamicCast(V, DCE), 1638 MakeQualifiers(E->getType())); 1639 } 1640 1641 case CastExpr::CK_NoOp: 1642 case CastExpr::CK_ConstructorConversion: 1643 case CastExpr::CK_UserDefinedConversion: 1644 case CastExpr::CK_AnyPointerToObjCPointerCast: 1645 return EmitLValue(E->getSubExpr()); 1646 1647 case CastExpr::CK_UncheckedDerivedToBase: 1648 case CastExpr::CK_DerivedToBase: { 1649 const RecordType *DerivedClassTy = 1650 E->getSubExpr()->getType()->getAs<RecordType>(); 1651 CXXRecordDecl *DerivedClassDecl = 1652 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1653 1654 const RecordType *BaseClassTy = E->getType()->getAs<RecordType>(); 1655 CXXRecordDecl *BaseClassDecl = cast<CXXRecordDecl>(BaseClassTy->getDecl()); 1656 1657 LValue LV = EmitLValue(E->getSubExpr()); 1658 1659 // Perform the derived-to-base conversion 1660 llvm::Value *Base = 1661 GetAddressOfBaseClass(LV.getAddress(), DerivedClassDecl, 1662 BaseClassDecl, /*NullCheckValue=*/false); 1663 1664 return LValue::MakeAddr(Base, MakeQualifiers(E->getType())); 1665 } 1666 case CastExpr::CK_ToUnion: 1667 return EmitAggExprToLValue(E); 1668 case CastExpr::CK_BaseToDerived: { 1669 const RecordType *BaseClassTy = 1670 E->getSubExpr()->getType()->getAs<RecordType>(); 1671 CXXRecordDecl *BaseClassDecl = 1672 cast<CXXRecordDecl>(BaseClassTy->getDecl()); 1673 1674 const RecordType *DerivedClassTy = E->getType()->getAs<RecordType>(); 1675 CXXRecordDecl *DerivedClassDecl = 1676 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1677 1678 LValue LV = EmitLValue(E->getSubExpr()); 1679 1680 // Perform the base-to-derived conversion 1681 llvm::Value *Derived = 1682 GetAddressOfDerivedClass(LV.getAddress(), BaseClassDecl, 1683 DerivedClassDecl, /*NullCheckValue=*/false); 1684 1685 return LValue::MakeAddr(Derived, MakeQualifiers(E->getType())); 1686 } 1687 case CastExpr::CK_BitCast: { 1688 // This must be a reinterpret_cast (or c-style equivalent). 1689 const ExplicitCastExpr *CE = cast<ExplicitCastExpr>(E); 1690 1691 LValue LV = EmitLValue(E->getSubExpr()); 1692 llvm::Value *V = Builder.CreateBitCast(LV.getAddress(), 1693 ConvertType(CE->getTypeAsWritten())); 1694 return LValue::MakeAddr(V, MakeQualifiers(E->getType())); 1695 } 1696 } 1697} 1698 1699LValue CodeGenFunction::EmitNullInitializationLValue( 1700 const CXXZeroInitValueExpr *E) { 1701 QualType Ty = E->getType(); 1702 LValue LV = LValue::MakeAddr(CreateMemTemp(Ty), MakeQualifiers(Ty)); 1703 EmitMemSetToZero(LV.getAddress(), Ty); 1704 return LV; 1705} 1706 1707//===--------------------------------------------------------------------===// 1708// Expression Emission 1709//===--------------------------------------------------------------------===// 1710 1711 1712RValue CodeGenFunction::EmitCallExpr(const CallExpr *E, 1713 ReturnValueSlot ReturnValue) { 1714 // Builtins never have block type. 1715 if (E->getCallee()->getType()->isBlockPointerType()) 1716 return EmitBlockCallExpr(E, ReturnValue); 1717 1718 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E)) 1719 return EmitCXXMemberCallExpr(CE, ReturnValue); 1720 1721 const Decl *TargetDecl = 0; 1722 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) { 1723 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) { 1724 TargetDecl = DRE->getDecl(); 1725 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl)) 1726 if (unsigned builtinID = FD->getBuiltinID()) 1727 return EmitBuiltinExpr(FD, builtinID, E); 1728 } 1729 } 1730 1731 if (const CXXOperatorCallExpr *CE = dyn_cast<CXXOperatorCallExpr>(E)) 1732 if (const CXXMethodDecl *MD = dyn_cast_or_null<CXXMethodDecl>(TargetDecl)) 1733 return EmitCXXOperatorMemberCallExpr(CE, MD, ReturnValue); 1734 1735 if (isa<CXXPseudoDestructorExpr>(E->getCallee()->IgnoreParens())) { 1736 // C++ [expr.pseudo]p1: 1737 // The result shall only be used as the operand for the function call 1738 // operator (), and the result of such a call has type void. The only 1739 // effect is the evaluation of the postfix-expression before the dot or 1740 // arrow. 1741 EmitScalarExpr(E->getCallee()); 1742 return RValue::get(0); 1743 } 1744 1745 llvm::Value *Callee = EmitScalarExpr(E->getCallee()); 1746 return EmitCall(E->getCallee()->getType(), Callee, ReturnValue, 1747 E->arg_begin(), E->arg_end(), TargetDecl); 1748} 1749 1750LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) { 1751 // Comma expressions just emit their LHS then their RHS as an l-value. 1752 if (E->getOpcode() == BinaryOperator::Comma) { 1753 EmitAnyExpr(E->getLHS()); 1754 EnsureInsertPoint(); 1755 return EmitLValue(E->getRHS()); 1756 } 1757 1758 if (E->getOpcode() == BinaryOperator::PtrMemD || 1759 E->getOpcode() == BinaryOperator::PtrMemI) 1760 return EmitPointerToDataMemberBinaryExpr(E); 1761 1762 // Can only get l-value for binary operator expressions which are a 1763 // simple assignment of aggregate type. 1764 if (E->getOpcode() != BinaryOperator::Assign) 1765 return EmitUnsupportedLValue(E, "binary l-value expression"); 1766 1767 if (!hasAggregateLLVMType(E->getType())) { 1768 // Emit the LHS as an l-value. 1769 LValue LV = EmitLValue(E->getLHS()); 1770 1771 llvm::Value *RHS = EmitScalarExpr(E->getRHS()); 1772 EmitStoreOfScalar(RHS, LV.getAddress(), LV.isVolatileQualified(), 1773 E->getType()); 1774 return LV; 1775 } 1776 1777 return EmitAggExprToLValue(E); 1778} 1779 1780LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) { 1781 RValue RV = EmitCallExpr(E); 1782 1783 if (!RV.isScalar()) 1784 return LValue::MakeAddr(RV.getAggregateAddr(),MakeQualifiers(E->getType())); 1785 1786 assert(E->getCallReturnType()->isReferenceType() && 1787 "Can't have a scalar return unless the return type is a " 1788 "reference type!"); 1789 1790 return LValue::MakeAddr(RV.getScalarVal(), MakeQualifiers(E->getType())); 1791} 1792 1793LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) { 1794 // FIXME: This shouldn't require another copy. 1795 return EmitAggExprToLValue(E); 1796} 1797 1798LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) { 1799 llvm::Value *Temp = CreateMemTemp(E->getType(), "tmp"); 1800 EmitCXXConstructExpr(Temp, E); 1801 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1802} 1803 1804LValue 1805CodeGenFunction::EmitCXXTypeidLValue(const CXXTypeidExpr *E) { 1806 llvm::Value *Temp = EmitCXXTypeidExpr(E); 1807 return LValue::MakeAddr(Temp, MakeQualifiers(E->getType())); 1808} 1809 1810LValue 1811CodeGenFunction::EmitCXXBindTemporaryLValue(const CXXBindTemporaryExpr *E) { 1812 LValue LV = EmitLValue(E->getSubExpr()); 1813 PushCXXTemporary(E->getTemporary(), LV.getAddress()); 1814 return LV; 1815} 1816 1817LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) { 1818 // Can only get l-value for message expression returning aggregate type 1819 RValue RV = EmitObjCMessageExpr(E); 1820 // FIXME: can this be volatile? 1821 return LValue::MakeAddr(RV.getAggregateAddr(), MakeQualifiers(E->getType())); 1822} 1823 1824llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface, 1825 const ObjCIvarDecl *Ivar) { 1826 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar); 1827} 1828 1829LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy, 1830 llvm::Value *BaseValue, 1831 const ObjCIvarDecl *Ivar, 1832 unsigned CVRQualifiers) { 1833 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue, 1834 Ivar, CVRQualifiers); 1835} 1836 1837LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) { 1838 // FIXME: A lot of the code below could be shared with EmitMemberExpr. 1839 llvm::Value *BaseValue = 0; 1840 const Expr *BaseExpr = E->getBase(); 1841 Qualifiers BaseQuals; 1842 QualType ObjectTy; 1843 if (E->isArrow()) { 1844 BaseValue = EmitScalarExpr(BaseExpr); 1845 ObjectTy = BaseExpr->getType()->getPointeeType(); 1846 BaseQuals = ObjectTy.getQualifiers(); 1847 } else { 1848 LValue BaseLV = EmitLValue(BaseExpr); 1849 // FIXME: this isn't right for bitfields. 1850 BaseValue = BaseLV.getAddress(); 1851 ObjectTy = BaseExpr->getType(); 1852 BaseQuals = ObjectTy.getQualifiers(); 1853 } 1854 1855 LValue LV = 1856 EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(), 1857 BaseQuals.getCVRQualifiers()); 1858 setObjCGCLValueClass(getContext(), E, LV); 1859 return LV; 1860} 1861 1862LValue 1863CodeGenFunction::EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E) { 1864 // This is a special l-value that just issues sends when we load or store 1865 // through it. 1866 return LValue::MakePropertyRef(E, E->getType().getCVRQualifiers()); 1867} 1868 1869LValue CodeGenFunction::EmitObjCKVCRefLValue( 1870 const ObjCImplicitSetterGetterRefExpr *E) { 1871 // This is a special l-value that just issues sends when we load or store 1872 // through it. 1873 return LValue::MakeKVCRef(E, E->getType().getCVRQualifiers()); 1874} 1875 1876LValue CodeGenFunction::EmitObjCSuperExprLValue(const ObjCSuperExpr *E) { 1877 return EmitUnsupportedLValue(E, "use of super"); 1878} 1879 1880LValue CodeGenFunction::EmitStmtExprLValue(const StmtExpr *E) { 1881 // Can only get l-value for message expression returning aggregate type 1882 RValue RV = EmitAnyExprToTemp(E); 1883 return LValue::MakeAddr(RV.getAggregateAddr(), MakeQualifiers(E->getType())); 1884} 1885 1886RValue CodeGenFunction::EmitCall(QualType CalleeType, llvm::Value *Callee, 1887 ReturnValueSlot ReturnValue, 1888 CallExpr::const_arg_iterator ArgBeg, 1889 CallExpr::const_arg_iterator ArgEnd, 1890 const Decl *TargetDecl) { 1891 // Get the actual function type. The callee type will always be a pointer to 1892 // function type or a block pointer type. 1893 assert(CalleeType->isFunctionPointerType() && 1894 "Call must have function pointer type!"); 1895 1896 CalleeType = getContext().getCanonicalType(CalleeType); 1897 1898 const FunctionType *FnType 1899 = cast<FunctionType>(cast<PointerType>(CalleeType)->getPointeeType()); 1900 QualType ResultType = FnType->getResultType(); 1901 1902 CallArgList Args; 1903 EmitCallArgs(Args, dyn_cast<FunctionProtoType>(FnType), ArgBeg, ArgEnd); 1904 1905 return EmitCall(CGM.getTypes().getFunctionInfo(Args, FnType), 1906 Callee, ReturnValue, Args, TargetDecl); 1907} 1908 1909LValue CodeGenFunction:: 1910EmitPointerToDataMemberBinaryExpr(const BinaryOperator *E) { 1911 llvm::Value *BaseV; 1912 if (E->getOpcode() == BinaryOperator::PtrMemI) 1913 BaseV = EmitScalarExpr(E->getLHS()); 1914 else 1915 BaseV = EmitLValue(E->getLHS()).getAddress(); 1916 const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(getLLVMContext()); 1917 BaseV = Builder.CreateBitCast(BaseV, i8Ty); 1918 llvm::Value *OffsetV = EmitScalarExpr(E->getRHS()); 1919 llvm::Value *AddV = Builder.CreateInBoundsGEP(BaseV, OffsetV, "add.ptr"); 1920 1921 QualType Ty = E->getRHS()->getType(); 1922 Ty = Ty->getAs<MemberPointerType>()->getPointeeType(); 1923 1924 const llvm::Type *PType = ConvertType(getContext().getPointerType(Ty)); 1925 AddV = Builder.CreateBitCast(AddV, PType); 1926 return LValue::MakeAddr(AddV, MakeQualifiers(Ty)); 1927} 1928 1929