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