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