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