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