CGExpr.cpp revision 7cabee5b18212bd3106aea8415b044b2b3b43518
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/Target/TargetData.h" 21using namespace clang; 22using namespace CodeGen; 23 24//===--------------------------------------------------------------------===// 25// Miscellaneous Helper Methods 26//===--------------------------------------------------------------------===// 27 28/// CreateTempAlloca - This creates a alloca and inserts it into the entry 29/// block. 30llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(const llvm::Type *Ty, 31 const char *Name) { 32 if (!Builder.isNamePreserving()) 33 Name = ""; 34 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt); 35} 36 37/// EvaluateExprAsBool - Perform the usual unary conversions on the specified 38/// expression and compare the result against zero, returning an Int1Ty value. 39llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) { 40 QualType BoolTy = getContext().BoolTy; 41 if (!E->getType()->isAnyComplexType()) 42 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy); 43 44 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy); 45} 46 47/// EmitAnyExpr - Emit code to compute the specified expression which can have 48/// any type. The result is returned as an RValue struct. If this is an 49/// aggregate expression, the aggloc/agglocvolatile arguments indicate where 50/// the result should be returned. 51RValue CodeGenFunction::EmitAnyExpr(const Expr *E, llvm::Value *AggLoc, 52 bool isAggLocVolatile) { 53 if (!hasAggregateLLVMType(E->getType())) 54 return RValue::get(EmitScalarExpr(E)); 55 else if (E->getType()->isAnyComplexType()) 56 return RValue::getComplex(EmitComplexExpr(E)); 57 58 EmitAggExpr(E, AggLoc, isAggLocVolatile); 59 return RValue::getAggregate(AggLoc); 60} 61 62/// EmitAnyExprToTemp - Similary to EmitAnyExpr(), however, the result 63/// will always be accessible even if no aggregate location is 64/// provided. 65RValue CodeGenFunction::EmitAnyExprToTemp(const Expr *E, llvm::Value *AggLoc, 66 bool isAggLocVolatile) { 67 if (!AggLoc && hasAggregateLLVMType(E->getType()) && 68 !E->getType()->isAnyComplexType()) 69 AggLoc = CreateTempAlloca(ConvertType(E->getType()), "agg.tmp"); 70 return EmitAnyExpr(E, AggLoc, isAggLocVolatile); 71} 72 73/// getAccessedFieldNo - Given an encoded value and a result number, return 74/// the input field number being accessed. 75unsigned CodeGenFunction::getAccessedFieldNo(unsigned Idx, 76 const llvm::Constant *Elts) { 77 if (isa<llvm::ConstantAggregateZero>(Elts)) 78 return 0; 79 80 return cast<llvm::ConstantInt>(Elts->getOperand(Idx))->getZExtValue(); 81} 82 83 84//===----------------------------------------------------------------------===// 85// LValue Expression Emission 86//===----------------------------------------------------------------------===// 87 88RValue CodeGenFunction::GetUndefRValue(QualType Ty) { 89 if (Ty->isVoidType()) { 90 return RValue::get(0); 91 } else if (const ComplexType *CTy = Ty->getAsComplexType()) { 92 const llvm::Type *EltTy = ConvertType(CTy->getElementType()); 93 llvm::Value *U = llvm::UndefValue::get(EltTy); 94 return RValue::getComplex(std::make_pair(U, U)); 95 } else if (hasAggregateLLVMType(Ty)) { 96 const llvm::Type *LTy = llvm::PointerType::getUnqual(ConvertType(Ty)); 97 return RValue::getAggregate(llvm::UndefValue::get(LTy)); 98 } else { 99 return RValue::get(llvm::UndefValue::get(ConvertType(Ty))); 100 } 101} 102 103RValue CodeGenFunction::EmitUnsupportedRValue(const Expr *E, 104 const char *Name) { 105 ErrorUnsupported(E, Name); 106 return GetUndefRValue(E->getType()); 107} 108 109LValue CodeGenFunction::EmitUnsupportedLValue(const Expr *E, 110 const char *Name) { 111 ErrorUnsupported(E, Name); 112 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 113 return LValue::MakeAddr(llvm::UndefValue::get(Ty), 114 E->getType().getCVRQualifiers(), 115 getContext().getObjCGCAttrKind(E->getType())); 116} 117 118/// EmitLValue - Emit code to compute a designator that specifies the location 119/// of the expression. 120/// 121/// This can return one of two things: a simple address or a bitfield 122/// reference. In either case, the LLVM Value* in the LValue structure is 123/// guaranteed to be an LLVM pointer type. 124/// 125/// If this returns a bitfield reference, nothing about the pointee type of 126/// the LLVM value is known: For example, it may not be a pointer to an 127/// integer. 128/// 129/// If this returns a normal address, and if the lvalue's C type is fixed 130/// size, this method guarantees that the returned pointer type will point to 131/// an LLVM type of the same size of the lvalue's type. If the lvalue has a 132/// variable length type, this is not possible. 133/// 134LValue CodeGenFunction::EmitLValue(const Expr *E) { 135 switch (E->getStmtClass()) { 136 default: return EmitUnsupportedLValue(E, "l-value expression"); 137 138 case Expr::BinaryOperatorClass: 139 return EmitBinaryOperatorLValue(cast<BinaryOperator>(E)); 140 case Expr::CallExprClass: 141 case Expr::CXXOperatorCallExprClass: 142 return EmitCallExprLValue(cast<CallExpr>(E)); 143 case Expr::VAArgExprClass: 144 return EmitVAArgExprLValue(cast<VAArgExpr>(E)); 145 case Expr::DeclRefExprClass: 146 case Expr::QualifiedDeclRefExprClass: 147 return EmitDeclRefLValue(cast<DeclRefExpr>(E)); 148 case Expr::ParenExprClass:return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 149 case Expr::PredefinedExprClass: 150 return EmitPredefinedLValue(cast<PredefinedExpr>(E)); 151 case Expr::StringLiteralClass: 152 return EmitStringLiteralLValue(cast<StringLiteral>(E)); 153 case Expr::ObjCEncodeExprClass: 154 return EmitObjCEncodeExprLValue(cast<ObjCEncodeExpr>(E)); 155 156 case Expr::BlockDeclRefExprClass: 157 return EmitBlockDeclRefLValue(cast<BlockDeclRefExpr>(E)); 158 159 case Expr::CXXConditionDeclExprClass: 160 return EmitCXXConditionDeclLValue(cast<CXXConditionDeclExpr>(E)); 161 162 case Expr::ObjCMessageExprClass: 163 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E)); 164 case Expr::ObjCIvarRefExprClass: 165 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E)); 166 case Expr::ObjCPropertyRefExprClass: 167 return EmitObjCPropertyRefLValue(cast<ObjCPropertyRefExpr>(E)); 168 case Expr::ObjCKVCRefExprClass: 169 return EmitObjCKVCRefLValue(cast<ObjCKVCRefExpr>(E)); 170 case Expr::ObjCSuperExprClass: 171 return EmitObjCSuperExpr(cast<ObjCSuperExpr>(E)); 172 173 case Expr::UnaryOperatorClass: 174 return EmitUnaryOpLValue(cast<UnaryOperator>(E)); 175 case Expr::ArraySubscriptExprClass: 176 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E)); 177 case Expr::ExtVectorElementExprClass: 178 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E)); 179 case Expr::MemberExprClass: return EmitMemberExpr(cast<MemberExpr>(E)); 180 case Expr::CompoundLiteralExprClass: 181 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E)); 182 case Expr::ConditionalOperatorClass: 183 return EmitConditionalOperator(cast<ConditionalOperator>(E)); 184 case Expr::ChooseExprClass: 185 return EmitLValue(cast<ChooseExpr>(E)->getChosenSubExpr(getContext())); 186 case Expr::ImplicitCastExprClass: 187 case Expr::CStyleCastExprClass: 188 case Expr::CXXFunctionalCastExprClass: 189 case Expr::CXXStaticCastExprClass: 190 case Expr::CXXDynamicCastExprClass: 191 case Expr::CXXReinterpretCastExprClass: 192 case Expr::CXXConstCastExprClass: 193 return EmitCastLValue(cast<CastExpr>(E)); 194 case Expr::CXXTemporaryObjectExprClass: 195 return EmitCXXTemporaryObjectExprLValue(cast<CXXTemporaryObjectExpr>(E)); 196 } 197} 198 199llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile, 200 QualType Ty) { 201 llvm::Value *V = Builder.CreateLoad(Addr, Volatile, "tmp"); 202 203 // Bool can have different representation in memory than in 204 // registers. 205 if (Ty->isBooleanType()) 206 if (V->getType() != llvm::Type::Int1Ty) 207 V = Builder.CreateTrunc(V, llvm::Type::Int1Ty, "tobool"); 208 209 return V; 210} 211 212void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr, 213 bool Volatile) { 214 // Handle stores of types which have different representations in 215 // memory and as LLVM values. 216 217 // FIXME: We shouldn't be this loose, we should only do this 218 // conversion when we have a type we know has a different memory 219 // representation (e.g., bool). 220 221 const llvm::Type *SrcTy = Value->getType(); 222 const llvm::PointerType *DstPtr = cast<llvm::PointerType>(Addr->getType()); 223 if (DstPtr->getElementType() != SrcTy) { 224 const llvm::Type *MemTy = 225 llvm::PointerType::get(SrcTy, DstPtr->getAddressSpace()); 226 Addr = Builder.CreateBitCast(Addr, MemTy, "storetmp"); 227 } 228 229 Builder.CreateStore(Value, Addr, Volatile); 230} 231 232/// EmitLoadOfLValue - Given an expression that represents a value lvalue, 233/// this method emits the address of the lvalue, then loads the result as an 234/// rvalue, returning the rvalue. 235RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, QualType ExprType) { 236 if (LV.isObjCWeak()) { 237 // load of a __weak object. 238 llvm::Value *AddrWeakObj = LV.getAddress(); 239 llvm::Value *read_weak = CGM.getObjCRuntime().EmitObjCWeakRead(*this, 240 AddrWeakObj); 241 return RValue::get(read_weak); 242 } 243 244 if (LV.isSimple()) { 245 llvm::Value *Ptr = LV.getAddress(); 246 const llvm::Type *EltTy = 247 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 248 249 // Simple scalar l-value. 250 if (EltTy->isSingleValueType()) 251 return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(), 252 ExprType)); 253 254 assert(ExprType->isFunctionType() && "Unknown scalar value"); 255 return RValue::get(Ptr); 256 } 257 258 if (LV.isVectorElt()) { 259 llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(), 260 LV.isVolatileQualified(), "tmp"); 261 return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(), 262 "vecext")); 263 } 264 265 // If this is a reference to a subset of the elements of a vector, either 266 // shuffle the input or extract/insert them as appropriate. 267 if (LV.isExtVectorElt()) 268 return EmitLoadOfExtVectorElementLValue(LV, ExprType); 269 270 if (LV.isBitfield()) 271 return EmitLoadOfBitfieldLValue(LV, ExprType); 272 273 if (LV.isPropertyRef()) 274 return EmitLoadOfPropertyRefLValue(LV, ExprType); 275 276 assert(LV.isKVCRef() && "Unknown LValue type!"); 277 return EmitLoadOfKVCRefLValue(LV, ExprType); 278} 279 280RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV, 281 QualType ExprType) { 282 unsigned StartBit = LV.getBitfieldStartBit(); 283 unsigned BitfieldSize = LV.getBitfieldSize(); 284 llvm::Value *Ptr = LV.getBitfieldAddr(); 285 286 const llvm::Type *EltTy = 287 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 288 unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy); 289 290 // In some cases the bitfield may straddle two memory locations. 291 // Currently we load the entire bitfield, then do the magic to 292 // sign-extend it if necessary. This results in somewhat more code 293 // than necessary for the common case (one load), since two shifts 294 // accomplish both the masking and sign extension. 295 unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit); 296 llvm::Value *Val = Builder.CreateLoad(Ptr, LV.isVolatileQualified(), "tmp"); 297 298 // Shift to proper location. 299 if (StartBit) 300 Val = Builder.CreateLShr(Val, llvm::ConstantInt::get(EltTy, StartBit), 301 "bf.lo"); 302 303 // Mask off unused bits. 304 llvm::Constant *LowMask = 305 llvm::ConstantInt::get(llvm::APInt::getLowBitsSet(EltTySize, LowBits)); 306 Val = Builder.CreateAnd(Val, LowMask, "bf.lo.cleared"); 307 308 // Fetch the high bits if necessary. 309 if (LowBits < BitfieldSize) { 310 unsigned HighBits = BitfieldSize - LowBits; 311 llvm::Value *HighPtr = 312 Builder.CreateGEP(Ptr, llvm::ConstantInt::get(llvm::Type::Int32Ty, 1), 313 "bf.ptr.hi"); 314 llvm::Value *HighVal = Builder.CreateLoad(HighPtr, 315 LV.isVolatileQualified(), 316 "tmp"); 317 318 // Mask off unused bits. 319 llvm::Constant *HighMask = 320 llvm::ConstantInt::get(llvm::APInt::getLowBitsSet(EltTySize, HighBits)); 321 HighVal = Builder.CreateAnd(HighVal, HighMask, "bf.lo.cleared"); 322 323 // Shift to proper location and or in to bitfield value. 324 HighVal = Builder.CreateShl(HighVal, 325 llvm::ConstantInt::get(EltTy, LowBits)); 326 Val = Builder.CreateOr(Val, HighVal, "bf.val"); 327 } 328 329 // Sign extend if necessary. 330 if (LV.isBitfieldSigned()) { 331 llvm::Value *ExtraBits = llvm::ConstantInt::get(EltTy, 332 EltTySize - BitfieldSize); 333 Val = Builder.CreateAShr(Builder.CreateShl(Val, ExtraBits), 334 ExtraBits, "bf.val.sext"); 335 } 336 337 // The bitfield type and the normal type differ when the storage sizes 338 // differ (currently just _Bool). 339 Val = Builder.CreateIntCast(Val, ConvertType(ExprType), false, "tmp"); 340 341 return RValue::get(Val); 342} 343 344RValue CodeGenFunction::EmitLoadOfPropertyRefLValue(LValue LV, 345 QualType ExprType) { 346 return EmitObjCPropertyGet(LV.getPropertyRefExpr()); 347} 348 349RValue CodeGenFunction::EmitLoadOfKVCRefLValue(LValue LV, 350 QualType ExprType) { 351 return EmitObjCPropertyGet(LV.getKVCRefExpr()); 352} 353 354// If this is a reference to a subset of the elements of a vector, create an 355// appropriate shufflevector. 356RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV, 357 QualType ExprType) { 358 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(), 359 LV.isVolatileQualified(), "tmp"); 360 361 const llvm::Constant *Elts = LV.getExtVectorElts(); 362 363 // If the result of the expression is a non-vector type, we must be 364 // extracting a single element. Just codegen as an extractelement. 365 const VectorType *ExprVT = ExprType->getAsVectorType(); 366 if (!ExprVT) { 367 unsigned InIdx = getAccessedFieldNo(0, Elts); 368 llvm::Value *Elt = llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx); 369 return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp")); 370 } 371 372 // Always use shuffle vector to try to retain the original program structure 373 unsigned NumResultElts = ExprVT->getNumElements(); 374 375 llvm::SmallVector<llvm::Constant*, 4> Mask; 376 for (unsigned i = 0; i != NumResultElts; ++i) { 377 unsigned InIdx = getAccessedFieldNo(i, Elts); 378 Mask.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx)); 379 } 380 381 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 382 Vec = Builder.CreateShuffleVector(Vec, 383 llvm::UndefValue::get(Vec->getType()), 384 MaskV, "tmp"); 385 return RValue::get(Vec); 386} 387 388 389 390/// EmitStoreThroughLValue - Store the specified rvalue into the specified 391/// lvalue, where both are guaranteed to the have the same type, and that type 392/// is 'Ty'. 393void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, 394 QualType Ty) { 395 if (!Dst.isSimple()) { 396 if (Dst.isVectorElt()) { 397 // Read/modify/write the vector, inserting the new element. 398 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(), 399 Dst.isVolatileQualified(), "tmp"); 400 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), 401 Dst.getVectorIdx(), "vecins"); 402 Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified()); 403 return; 404 } 405 406 // If this is an update of extended vector elements, insert them as 407 // appropriate. 408 if (Dst.isExtVectorElt()) 409 return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty); 410 411 if (Dst.isBitfield()) 412 return EmitStoreThroughBitfieldLValue(Src, Dst, Ty); 413 414 if (Dst.isPropertyRef()) 415 return EmitStoreThroughPropertyRefLValue(Src, Dst, Ty); 416 417 if (Dst.isKVCRef()) 418 return EmitStoreThroughKVCRefLValue(Src, Dst, Ty); 419 420 assert(0 && "Unknown LValue type"); 421 } 422 423 if (Dst.isObjCWeak() && !Dst.isNonGC()) { 424 // load of a __weak object. 425 llvm::Value *LvalueDst = Dst.getAddress(); 426 llvm::Value *src = Src.getScalarVal(); 427 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst); 428 return; 429 } 430 431 if (Dst.isObjCStrong() && !Dst.isNonGC()) { 432 // load of a __strong object. 433 llvm::Value *LvalueDst = Dst.getAddress(); 434 llvm::Value *src = Src.getScalarVal(); 435#if 0 436 // FIXME. We cannot positively determine if we have an 437 // 'ivar' assignment, object assignment or an unknown 438 // assignment. For now, generate call to objc_assign_strongCast 439 // assignment which is a safe, but consevative assumption. 440 if (Dst.isObjCIvar()) 441 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, LvalueDst); 442 else 443 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst); 444#endif 445 CGM.getObjCRuntime().EmitObjCStrongCastAssign(*this, src, LvalueDst); 446 return; 447 } 448 449 assert(Src.isScalar() && "Can't emit an agg store with this method"); 450 EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(), 451 Dst.isVolatileQualified()); 452} 453 454void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 455 QualType Ty, 456 llvm::Value **Result) { 457 unsigned StartBit = Dst.getBitfieldStartBit(); 458 unsigned BitfieldSize = Dst.getBitfieldSize(); 459 llvm::Value *Ptr = Dst.getBitfieldAddr(); 460 461 const llvm::Type *EltTy = 462 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 463 unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy); 464 465 // Get the new value, cast to the appropriate type and masked to 466 // exactly the size of the bit-field. 467 llvm::Value *SrcVal = Src.getScalarVal(); 468 llvm::Value *NewVal = Builder.CreateIntCast(SrcVal, EltTy, false, "tmp"); 469 llvm::Constant *Mask = 470 llvm::ConstantInt::get(llvm::APInt::getLowBitsSet(EltTySize, BitfieldSize)); 471 NewVal = Builder.CreateAnd(NewVal, Mask, "bf.value"); 472 473 // Return the new value of the bit-field, if requested. 474 if (Result) { 475 // Cast back to the proper type for result. 476 const llvm::Type *SrcTy = SrcVal->getType(); 477 llvm::Value *SrcTrunc = Builder.CreateIntCast(NewVal, SrcTy, false, 478 "bf.reload.val"); 479 480 // Sign extend if necessary. 481 if (Dst.isBitfieldSigned()) { 482 unsigned SrcTySize = CGM.getTargetData().getTypeSizeInBits(SrcTy); 483 llvm::Value *ExtraBits = llvm::ConstantInt::get(SrcTy, 484 SrcTySize - BitfieldSize); 485 SrcTrunc = Builder.CreateAShr(Builder.CreateShl(SrcTrunc, ExtraBits), 486 ExtraBits, "bf.reload.sext"); 487 } 488 489 *Result = SrcTrunc; 490 } 491 492 // In some cases the bitfield may straddle two memory locations. 493 // Emit the low part first and check to see if the high needs to be 494 // done. 495 unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit); 496 llvm::Value *LowVal = Builder.CreateLoad(Ptr, Dst.isVolatileQualified(), 497 "bf.prev.low"); 498 499 // Compute the mask for zero-ing the low part of this bitfield. 500 llvm::Constant *InvMask = 501 llvm::ConstantInt::get(~llvm::APInt::getBitsSet(EltTySize, StartBit, 502 StartBit + LowBits)); 503 504 // Compute the new low part as 505 // LowVal = (LowVal & InvMask) | (NewVal << StartBit), 506 // with the shift of NewVal implicitly stripping the high bits. 507 llvm::Value *NewLowVal = 508 Builder.CreateShl(NewVal, llvm::ConstantInt::get(EltTy, StartBit), 509 "bf.value.lo"); 510 LowVal = Builder.CreateAnd(LowVal, InvMask, "bf.prev.lo.cleared"); 511 LowVal = Builder.CreateOr(LowVal, NewLowVal, "bf.new.lo"); 512 513 // Write back. 514 Builder.CreateStore(LowVal, Ptr, Dst.isVolatileQualified()); 515 516 // If the low part doesn't cover the bitfield emit a high part. 517 if (LowBits < BitfieldSize) { 518 unsigned HighBits = BitfieldSize - LowBits; 519 llvm::Value *HighPtr = 520 Builder.CreateGEP(Ptr, llvm::ConstantInt::get(llvm::Type::Int32Ty, 1), 521 "bf.ptr.hi"); 522 llvm::Value *HighVal = Builder.CreateLoad(HighPtr, 523 Dst.isVolatileQualified(), 524 "bf.prev.hi"); 525 526 // Compute the mask for zero-ing the high part of this bitfield. 527 llvm::Constant *InvMask = 528 llvm::ConstantInt::get(~llvm::APInt::getLowBitsSet(EltTySize, HighBits)); 529 530 // Compute the new high part as 531 // HighVal = (HighVal & InvMask) | (NewVal lshr LowBits), 532 // where the high bits of NewVal have already been cleared and the 533 // shift stripping the low bits. 534 llvm::Value *NewHighVal = 535 Builder.CreateLShr(NewVal, llvm::ConstantInt::get(EltTy, LowBits), 536 "bf.value.high"); 537 HighVal = Builder.CreateAnd(HighVal, InvMask, "bf.prev.hi.cleared"); 538 HighVal = Builder.CreateOr(HighVal, NewHighVal, "bf.new.hi"); 539 540 // Write back. 541 Builder.CreateStore(HighVal, HighPtr, Dst.isVolatileQualified()); 542 } 543} 544 545void CodeGenFunction::EmitStoreThroughPropertyRefLValue(RValue Src, 546 LValue Dst, 547 QualType Ty) { 548 EmitObjCPropertySet(Dst.getPropertyRefExpr(), Src); 549} 550 551void CodeGenFunction::EmitStoreThroughKVCRefLValue(RValue Src, 552 LValue Dst, 553 QualType Ty) { 554 EmitObjCPropertySet(Dst.getKVCRefExpr(), Src); 555} 556 557void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, 558 LValue Dst, 559 QualType Ty) { 560 // This access turns into a read/modify/write of the vector. Load the input 561 // value now. 562 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(), 563 Dst.isVolatileQualified(), "tmp"); 564 const llvm::Constant *Elts = Dst.getExtVectorElts(); 565 566 llvm::Value *SrcVal = Src.getScalarVal(); 567 568 if (const VectorType *VTy = Ty->getAsVectorType()) { 569 unsigned NumSrcElts = VTy->getNumElements(); 570 unsigned NumDstElts = 571 cast<llvm::VectorType>(Vec->getType())->getNumElements(); 572 if (NumDstElts == NumSrcElts) { 573 // Use shuffle vector is the src and destination are the same number 574 // of elements 575 llvm::SmallVector<llvm::Constant*, 4> Mask; 576 for (unsigned i = 0; i != NumSrcElts; ++i) { 577 unsigned InIdx = getAccessedFieldNo(i, Elts); 578 Mask.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx)); 579 } 580 581 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 582 Vec = Builder.CreateShuffleVector(SrcVal, 583 llvm::UndefValue::get(Vec->getType()), 584 MaskV, "tmp"); 585 } 586 else if (NumDstElts > NumSrcElts) { 587 // Extended the source vector to the same length and then shuffle it 588 // into the destination. 589 // FIXME: since we're shuffling with undef, can we just use the indices 590 // into that? This could be simpler. 591 llvm::SmallVector<llvm::Constant*, 4> ExtMask; 592 unsigned i; 593 for (i = 0; i != NumSrcElts; ++i) 594 ExtMask.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, i)); 595 for (; i != NumDstElts; ++i) 596 ExtMask.push_back(llvm::UndefValue::get(llvm::Type::Int32Ty)); 597 llvm::Value *ExtMaskV = llvm::ConstantVector::get(&ExtMask[0], 598 ExtMask.size()); 599 llvm::Value *ExtSrcVal = 600 Builder.CreateShuffleVector(SrcVal, 601 llvm::UndefValue::get(SrcVal->getType()), 602 ExtMaskV, "tmp"); 603 // build identity 604 llvm::SmallVector<llvm::Constant*, 4> Mask; 605 for (unsigned i = 0; i != NumDstElts; ++i) { 606 Mask.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, i)); 607 } 608 // modify when what gets shuffled in 609 for (unsigned i = 0; i != NumSrcElts; ++i) { 610 unsigned Idx = getAccessedFieldNo(i, Elts); 611 Mask[Idx] =llvm::ConstantInt::get(llvm::Type::Int32Ty, i+NumDstElts); 612 } 613 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 614 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp"); 615 } 616 else { 617 // We should never shorten the vector 618 assert(0 && "unexpected shorten vector length"); 619 } 620 } else { 621 // If the Src is a scalar (not a vector) it must be updating one element. 622 unsigned InIdx = getAccessedFieldNo(0, Elts); 623 llvm::Value *Elt = llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx); 624 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp"); 625 } 626 627 Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified()); 628} 629 630LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { 631 const VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()); 632 633 if (VD && (VD->isBlockVarDecl() || isa<ParmVarDecl>(VD) || 634 isa<ImplicitParamDecl>(VD))) { 635 LValue LV; 636 bool GCable = VD->hasLocalStorage() && !VD->hasAttr<BlocksAttr>(); 637 if (VD->hasExternalStorage()) { 638 LV = LValue::MakeAddr(CGM.GetAddrOfGlobalVar(VD), 639 E->getType().getCVRQualifiers(), 640 getContext().getObjCGCAttrKind(E->getType())); 641 } 642 else { 643 llvm::Value *V = LocalDeclMap[VD]; 644 assert(V && "DeclRefExpr not entered in LocalDeclMap?"); 645 // local variables do not get their gc attribute set. 646 QualType::GCAttrTypes attr = QualType::GCNone; 647 // local static? 648 if (!GCable) 649 attr = getContext().getObjCGCAttrKind(E->getType()); 650 if (VD->hasAttr<BlocksAttr>()) { 651 bool needsCopyDispose = BlockRequiresCopying(VD->getType()); 652 const llvm::Type *PtrStructTy = V->getType(); 653 const llvm::Type *Ty = PtrStructTy; 654 Ty = llvm::PointerType::get(Ty, 0); 655 V = Builder.CreateStructGEP(V, 1, "forwarding"); 656 V = Builder.CreateBitCast(V, Ty); 657 V = Builder.CreateLoad(V, false); 658 V = Builder.CreateBitCast(V, PtrStructTy); 659 V = Builder.CreateStructGEP(V, needsCopyDispose*2 + 4, "x"); 660 } 661 LV = LValue::MakeAddr(V, E->getType().getCVRQualifiers(), attr); 662 } 663 LValue::SetObjCNonGC(LV, GCable); 664 return LV; 665 } else if (VD && VD->isFileVarDecl()) { 666 LValue LV = LValue::MakeAddr(CGM.GetAddrOfGlobalVar(VD), 667 E->getType().getCVRQualifiers(), 668 getContext().getObjCGCAttrKind(E->getType())); 669 return LV; 670 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(E->getDecl())) { 671 return LValue::MakeAddr(CGM.GetAddrOfFunction(FD), 672 E->getType().getCVRQualifiers(), 673 getContext().getObjCGCAttrKind(E->getType())); 674 } 675 else if (const ImplicitParamDecl *IPD = 676 dyn_cast<ImplicitParamDecl>(E->getDecl())) { 677 llvm::Value *V = LocalDeclMap[IPD]; 678 assert(V && "BlockVarDecl not entered in LocalDeclMap?"); 679 return LValue::MakeAddr(V, E->getType().getCVRQualifiers(), 680 getContext().getObjCGCAttrKind(E->getType())); 681 } 682 assert(0 && "Unimp declref"); 683 //an invalid LValue, but the assert will 684 //ensure that this point is never reached. 685 return LValue(); 686} 687 688LValue CodeGenFunction::EmitBlockDeclRefLValue(const BlockDeclRefExpr *E) { 689 return LValue::MakeAddr(GetAddrOfBlockDecl(E), 0); 690} 691 692LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { 693 // __extension__ doesn't affect lvalue-ness. 694 if (E->getOpcode() == UnaryOperator::Extension) 695 return EmitLValue(E->getSubExpr()); 696 697 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType()); 698 switch (E->getOpcode()) { 699 default: assert(0 && "Unknown unary operator lvalue!"); 700 case UnaryOperator::Deref: 701 { 702 QualType T = 703 E->getSubExpr()->getType()->getAsPointerType()->getPointeeType(); 704 LValue LV = LValue::MakeAddr(EmitScalarExpr(E->getSubExpr()), 705 ExprTy->getAsPointerType()->getPointeeType() 706 .getCVRQualifiers(), 707 getContext().getObjCGCAttrKind(T)); 708 // We should not generate __weak write barrier on indirect reference 709 // of a pointer to object; as in void foo (__weak id *param); *param = 0; 710 // But, we continue to generate __strong write barrier on indirect write 711 // into a pointer to object. 712 if (getContext().getLangOptions().ObjC1 && 713 getContext().getLangOptions().getGCMode() != LangOptions::NonGC && 714 LV.isObjCWeak()) 715 LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate()); 716 return LV; 717 } 718 case UnaryOperator::Real: 719 case UnaryOperator::Imag: 720 LValue LV = EmitLValue(E->getSubExpr()); 721 unsigned Idx = E->getOpcode() == UnaryOperator::Imag; 722 return LValue::MakeAddr(Builder.CreateStructGEP(LV.getAddress(), 723 Idx, "idx"), 724 ExprTy.getCVRQualifiers()); 725 } 726} 727 728LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { 729 return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromLiteral(E), 0); 730} 731 732LValue CodeGenFunction::EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E) { 733 return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromObjCEncode(E), 0); 734} 735 736 737LValue CodeGenFunction::EmitPredefinedFunctionName(unsigned Type) { 738 std::string GlobalVarName; 739 740 switch (Type) { 741 default: 742 assert(0 && "Invalid type"); 743 case PredefinedExpr::Func: 744 GlobalVarName = "__func__."; 745 break; 746 case PredefinedExpr::Function: 747 GlobalVarName = "__FUNCTION__."; 748 break; 749 case PredefinedExpr::PrettyFunction: 750 // FIXME:: Demangle C++ method names 751 GlobalVarName = "__PRETTY_FUNCTION__."; 752 break; 753 } 754 755 // FIXME: This isn't right at all. The logic for computing this should go 756 // into a method on PredefinedExpr. This would allow sema and codegen to be 757 // consistent for things like sizeof(__func__) etc. 758 std::string FunctionName; 759 if (const FunctionDecl *FD = dyn_cast_or_null<FunctionDecl>(CurCodeDecl)) { 760 FunctionName = CGM.getMangledName(FD); 761 } else { 762 // Just get the mangled name; skipping the asm prefix if it 763 // exists. 764 FunctionName = CurFn->getName(); 765 if (FunctionName[0] == '\01') 766 FunctionName = FunctionName.substr(1, std::string::npos); 767 } 768 769 GlobalVarName += FunctionName; 770 llvm::Constant *C = 771 CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str()); 772 return LValue::MakeAddr(C, 0); 773} 774 775LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { 776 switch (E->getIdentType()) { 777 default: 778 return EmitUnsupportedLValue(E, "predefined expression"); 779 case PredefinedExpr::Func: 780 case PredefinedExpr::Function: 781 case PredefinedExpr::PrettyFunction: 782 return EmitPredefinedFunctionName(E->getIdentType()); 783 } 784} 785 786LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { 787 // The index must always be an integer, which is not an aggregate. Emit it. 788 llvm::Value *Idx = EmitScalarExpr(E->getIdx()); 789 790 // If the base is a vector type, then we are forming a vector element lvalue 791 // with this subscript. 792 if (E->getBase()->getType()->isVectorType()) { 793 // Emit the vector as an lvalue to get its address. 794 LValue LHS = EmitLValue(E->getBase()); 795 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 796 // FIXME: This should properly sign/zero/extend or truncate Idx to i32. 797 return LValue::MakeVectorElt(LHS.getAddress(), Idx, 798 E->getBase()->getType().getCVRQualifiers()); 799 } 800 801 // The base must be a pointer, which is not an aggregate. Emit it. 802 llvm::Value *Base = EmitScalarExpr(E->getBase()); 803 804 // Extend or truncate the index type to 32 or 64-bits. 805 QualType IdxTy = E->getIdx()->getType(); 806 bool IdxSigned = IdxTy->isSignedIntegerType(); 807 unsigned IdxBitwidth = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 808 if (IdxBitwidth != LLVMPointerWidth) 809 Idx = Builder.CreateIntCast(Idx, llvm::IntegerType::get(LLVMPointerWidth), 810 IdxSigned, "idxprom"); 811 812 // We know that the pointer points to a type of the correct size, unless the 813 // size is a VLA. 814 if (const VariableArrayType *VAT = 815 getContext().getAsVariableArrayType(E->getType())) { 816 llvm::Value *VLASize = VLASizeMap[VAT]; 817 818 Idx = Builder.CreateMul(Idx, VLASize); 819 820 QualType BaseType = getContext().getBaseElementType(VAT); 821 822 uint64_t BaseTypeSize = getContext().getTypeSize(BaseType) / 8; 823 Idx = Builder.CreateUDiv(Idx, 824 llvm::ConstantInt::get(Idx->getType(), 825 BaseTypeSize)); 826 } 827 828 QualType T = E->getBase()->getType()->getAsPointerType()->getPointeeType(); 829 LValue LV = LValue::MakeAddr(Builder.CreateGEP(Base, Idx, "arrayidx"), 830 T.getCVRQualifiers(), 831 getContext().getObjCGCAttrKind(T)); 832 if (getContext().getLangOptions().ObjC1 && 833 getContext().getLangOptions().getGCMode() != LangOptions::NonGC) 834 LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate()); 835 return LV; 836} 837 838static 839llvm::Constant *GenerateConstantVector(llvm::SmallVector<unsigned, 4> &Elts) { 840 llvm::SmallVector<llvm::Constant *, 4> CElts; 841 842 for (unsigned i = 0, e = Elts.size(); i != e; ++i) 843 CElts.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, Elts[i])); 844 845 return llvm::ConstantVector::get(&CElts[0], CElts.size()); 846} 847 848LValue CodeGenFunction:: 849EmitExtVectorElementExpr(const ExtVectorElementExpr *E) { 850 // Emit the base vector as an l-value. 851 LValue Base; 852 853 // ExtVectorElementExpr's base can either be a vector or pointer to vector. 854 if (!E->isArrow()) { 855 assert(E->getBase()->getType()->isVectorType()); 856 Base = EmitLValue(E->getBase()); 857 } else { 858 const PointerType *PT = E->getBase()->getType()->getAsPointerType(); 859 llvm::Value *Ptr = EmitScalarExpr(E->getBase()); 860 Base = LValue::MakeAddr(Ptr, PT->getPointeeType().getCVRQualifiers()); 861 } 862 863 // Encode the element access list into a vector of unsigned indices. 864 llvm::SmallVector<unsigned, 4> Indices; 865 E->getEncodedElementAccess(Indices); 866 867 if (Base.isSimple()) { 868 llvm::Constant *CV = GenerateConstantVector(Indices); 869 return LValue::MakeExtVectorElt(Base.getAddress(), CV, 870 Base.getQualifiers()); 871 } 872 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!"); 873 874 llvm::Constant *BaseElts = Base.getExtVectorElts(); 875 llvm::SmallVector<llvm::Constant *, 4> CElts; 876 877 for (unsigned i = 0, e = Indices.size(); i != e; ++i) { 878 if (isa<llvm::ConstantAggregateZero>(BaseElts)) 879 CElts.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, 0)); 880 else 881 CElts.push_back(BaseElts->getOperand(Indices[i])); 882 } 883 llvm::Constant *CV = llvm::ConstantVector::get(&CElts[0], CElts.size()); 884 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, 885 Base.getQualifiers()); 886} 887 888LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { 889 bool isUnion = false; 890 bool isIvar = false; 891 bool isNonGC = false; 892 Expr *BaseExpr = E->getBase(); 893 llvm::Value *BaseValue = NULL; 894 unsigned CVRQualifiers=0; 895 896 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 897 if (E->isArrow()) { 898 BaseValue = EmitScalarExpr(BaseExpr); 899 const PointerType *PTy = 900 BaseExpr->getType()->getAsPointerType(); 901 if (PTy->getPointeeType()->isUnionType()) 902 isUnion = true; 903 CVRQualifiers = PTy->getPointeeType().getCVRQualifiers(); 904 } else if (isa<ObjCPropertyRefExpr>(BaseExpr) || 905 isa<ObjCKVCRefExpr>(BaseExpr)) { 906 RValue RV = EmitObjCPropertyGet(BaseExpr); 907 BaseValue = RV.getAggregateAddr(); 908 if (BaseExpr->getType()->isUnionType()) 909 isUnion = true; 910 CVRQualifiers = BaseExpr->getType().getCVRQualifiers(); 911 } else { 912 LValue BaseLV = EmitLValue(BaseExpr); 913 if (BaseLV.isObjCIvar()) 914 isIvar = true; 915 if (BaseLV.isNonGC()) 916 isNonGC = true; 917 // FIXME: this isn't right for bitfields. 918 BaseValue = BaseLV.getAddress(); 919 if (BaseExpr->getType()->isUnionType()) 920 isUnion = true; 921 CVRQualifiers = BaseExpr->getType().getCVRQualifiers(); 922 } 923 924 FieldDecl *Field = dyn_cast<FieldDecl>(E->getMemberDecl()); 925 // FIXME: Handle non-field member expressions 926 assert(Field && "No code generation for non-field member references"); 927 LValue MemExpLV = EmitLValueForField(BaseValue, Field, isUnion, 928 CVRQualifiers); 929 LValue::SetObjCIvar(MemExpLV, isIvar); 930 LValue::SetObjCNonGC(MemExpLV, isNonGC); 931 return MemExpLV; 932} 933 934LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value* BaseValue, 935 FieldDecl* Field, 936 unsigned CVRQualifiers) { 937 unsigned idx = CGM.getTypes().getLLVMFieldNo(Field); 938 // FIXME: CodeGenTypes should expose a method to get the appropriate 939 // type for FieldTy (the appropriate type is ABI-dependent). 940 const llvm::Type *FieldTy = 941 CGM.getTypes().ConvertTypeForMem(Field->getType()); 942 const llvm::PointerType *BaseTy = 943 cast<llvm::PointerType>(BaseValue->getType()); 944 unsigned AS = BaseTy->getAddressSpace(); 945 BaseValue = Builder.CreateBitCast(BaseValue, 946 llvm::PointerType::get(FieldTy, AS), 947 "tmp"); 948 llvm::Value *V = Builder.CreateGEP(BaseValue, 949 llvm::ConstantInt::get(llvm::Type::Int32Ty, idx), 950 "tmp"); 951 952 CodeGenTypes::BitFieldInfo bitFieldInfo = 953 CGM.getTypes().getBitFieldInfo(Field); 954 return LValue::MakeBitfield(V, bitFieldInfo.Begin, bitFieldInfo.Size, 955 Field->getType()->isSignedIntegerType(), 956 Field->getType().getCVRQualifiers()|CVRQualifiers); 957} 958 959LValue CodeGenFunction::EmitLValueForField(llvm::Value* BaseValue, 960 FieldDecl* Field, 961 bool isUnion, 962 unsigned CVRQualifiers) 963{ 964 if (Field->isBitField()) 965 return EmitLValueForBitfield(BaseValue, Field, CVRQualifiers); 966 967 unsigned idx = CGM.getTypes().getLLVMFieldNo(Field); 968 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp"); 969 970 // Match union field type. 971 if (isUnion) { 972 const llvm::Type *FieldTy = 973 CGM.getTypes().ConvertTypeForMem(Field->getType()); 974 const llvm::PointerType * BaseTy = 975 cast<llvm::PointerType>(BaseValue->getType()); 976 unsigned AS = BaseTy->getAddressSpace(); 977 V = Builder.CreateBitCast(V, 978 llvm::PointerType::get(FieldTy, AS), 979 "tmp"); 980 } 981 982 QualType::GCAttrTypes attr = QualType::GCNone; 983 if (CGM.getLangOptions().ObjC1 && 984 CGM.getLangOptions().getGCMode() != LangOptions::NonGC) { 985 QualType Ty = Field->getType(); 986 attr = Ty.getObjCGCAttr(); 987 if (attr != QualType::GCNone) { 988 // __weak attribute on a field is ignored. 989 if (attr == QualType::Weak) 990 attr = QualType::GCNone; 991 } 992 else if (getContext().isObjCObjectPointerType(Ty)) 993 attr = QualType::Strong; 994 } 995 LValue LV = 996 LValue::MakeAddr(V, 997 Field->getType().getCVRQualifiers()|CVRQualifiers, 998 attr); 999 return LV; 1000} 1001 1002LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr* E){ 1003 const llvm::Type *LTy = ConvertType(E->getType()); 1004 llvm::Value *DeclPtr = CreateTempAlloca(LTy, ".compoundliteral"); 1005 1006 const Expr* InitExpr = E->getInitializer(); 1007 LValue Result = LValue::MakeAddr(DeclPtr, E->getType().getCVRQualifiers()); 1008 1009 if (E->getType()->isComplexType()) { 1010 EmitComplexExprIntoAddr(InitExpr, DeclPtr, false); 1011 } else if (hasAggregateLLVMType(E->getType())) { 1012 EmitAnyExpr(InitExpr, DeclPtr, false); 1013 } else { 1014 EmitStoreThroughLValue(EmitAnyExpr(InitExpr), Result, E->getType()); 1015 } 1016 1017 return Result; 1018} 1019 1020LValue CodeGenFunction::EmitConditionalOperator(const ConditionalOperator* E) { 1021 // We don't handle vectors yet. 1022 if (E->getType()->isVectorType()) 1023 return EmitUnsupportedLValue(E, "conditional operator"); 1024 1025 // ?: here should be an aggregate. 1026 assert((hasAggregateLLVMType(E->getType()) && 1027 !E->getType()->isAnyComplexType()) && 1028 "Unexpected conditional operator!"); 1029 1030 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1031 EmitAggExpr(E, Temp, false); 1032 1033 return LValue::MakeAddr(Temp, E->getType().getCVRQualifiers(), 1034 getContext().getObjCGCAttrKind(E->getType())); 1035 1036} 1037 1038/// EmitCastLValue - Casts are never lvalues. If a cast is needed by the code 1039/// generator in an lvalue context, then it must mean that we need the address 1040/// of an aggregate in order to access one of its fields. This can happen for 1041/// all the reasons that casts are permitted with aggregate result, including 1042/// noop aggregate casts, and cast from scalar to union. 1043LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { 1044 // If this is an aggregate-to-aggregate cast, just use the input's address as 1045 // the lvalue. 1046 if (getContext().hasSameUnqualifiedType(E->getType(), 1047 E->getSubExpr()->getType())) 1048 return EmitLValue(E->getSubExpr()); 1049 1050 // Otherwise, we must have a cast from scalar to union. 1051 assert(E->getType()->isUnionType() && "Expected scalar-to-union cast"); 1052 1053 // Casts are only lvalues when the source and destination types are the same. 1054 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1055 EmitAnyExpr(E->getSubExpr(), Temp, false); 1056 1057 return LValue::MakeAddr(Temp, E->getType().getCVRQualifiers(), 1058 getContext().getObjCGCAttrKind(E->getType())); 1059} 1060 1061//===--------------------------------------------------------------------===// 1062// Expression Emission 1063//===--------------------------------------------------------------------===// 1064 1065 1066RValue CodeGenFunction::EmitCallExpr(const CallExpr *E) { 1067 // Builtins never have block type. 1068 if (E->getCallee()->getType()->isBlockPointerType()) 1069 return EmitBlockCallExpr(E); 1070 1071 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E)) 1072 return EmitCXXMemberCallExpr(CE); 1073 1074 const Decl *TargetDecl = 0; 1075 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) { 1076 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) { 1077 TargetDecl = DRE->getDecl(); 1078 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl)) 1079 if (unsigned builtinID = FD->getBuiltinID(getContext())) 1080 return EmitBuiltinExpr(FD, builtinID, E); 1081 } 1082 } 1083 1084 llvm::Value *Callee = EmitScalarExpr(E->getCallee()); 1085 return EmitCallExpr(Callee, E->getCallee()->getType(), 1086 E->arg_begin(), E->arg_end(), TargetDecl); 1087} 1088 1089LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) { 1090 // Can only get l-value for binary operator expressions which are a 1091 // simple assignment of aggregate type. 1092 if (E->getOpcode() != BinaryOperator::Assign) 1093 return EmitUnsupportedLValue(E, "binary l-value expression"); 1094 1095 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1096 EmitAggExpr(E, Temp, false); 1097 // FIXME: Are these qualifiers correct? 1098 return LValue::MakeAddr(Temp, E->getType().getCVRQualifiers(), 1099 getContext().getObjCGCAttrKind(E->getType())); 1100} 1101 1102LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) { 1103 // Can only get l-value for call expression returning aggregate type 1104 RValue RV = EmitCallExpr(E); 1105 return LValue::MakeAddr(RV.getAggregateAddr(), 1106 E->getType().getCVRQualifiers(), 1107 getContext().getObjCGCAttrKind(E->getType())); 1108} 1109 1110LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) { 1111 // FIXME: This shouldn't require another copy. 1112 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1113 EmitAggExpr(E, Temp, false); 1114 return LValue::MakeAddr(Temp, E->getType().getCVRQualifiers()); 1115} 1116 1117LValue 1118CodeGenFunction::EmitCXXConditionDeclLValue(const CXXConditionDeclExpr *E) { 1119 EmitLocalBlockVarDecl(*E->getVarDecl()); 1120 return EmitDeclRefLValue(E); 1121} 1122 1123LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) { 1124 // Can only get l-value for message expression returning aggregate type 1125 RValue RV = EmitObjCMessageExpr(E); 1126 // FIXME: can this be volatile? 1127 return LValue::MakeAddr(RV.getAggregateAddr(), 1128 E->getType().getCVRQualifiers(), 1129 getContext().getObjCGCAttrKind(E->getType())); 1130} 1131 1132llvm::Value *CodeGenFunction::EmitIvarOffset(const ObjCInterfaceDecl *Interface, 1133 const ObjCIvarDecl *Ivar) { 1134 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar); 1135} 1136 1137LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy, 1138 llvm::Value *BaseValue, 1139 const ObjCIvarDecl *Ivar, 1140 unsigned CVRQualifiers) { 1141 return CGM.getObjCRuntime().EmitObjCValueForIvar(*this, ObjectTy, BaseValue, 1142 Ivar, CVRQualifiers); 1143} 1144 1145LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) { 1146 // FIXME: A lot of the code below could be shared with EmitMemberExpr. 1147 llvm::Value *BaseValue = 0; 1148 const Expr *BaseExpr = E->getBase(); 1149 unsigned CVRQualifiers = 0; 1150 QualType ObjectTy; 1151 if (E->isArrow()) { 1152 BaseValue = EmitScalarExpr(BaseExpr); 1153 const PointerType *PTy = BaseExpr->getType()->getAsPointerType(); 1154 ObjectTy = PTy->getPointeeType(); 1155 CVRQualifiers = ObjectTy.getCVRQualifiers(); 1156 } else { 1157 LValue BaseLV = EmitLValue(BaseExpr); 1158 // FIXME: this isn't right for bitfields. 1159 BaseValue = BaseLV.getAddress(); 1160 ObjectTy = BaseExpr->getType(); 1161 CVRQualifiers = ObjectTy.getCVRQualifiers(); 1162 } 1163 1164 return EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(), CVRQualifiers); 1165} 1166 1167LValue 1168CodeGenFunction::EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E) { 1169 // This is a special l-value that just issues sends when we load or 1170 // store through it. 1171 return LValue::MakePropertyRef(E, E->getType().getCVRQualifiers()); 1172} 1173 1174LValue 1175CodeGenFunction::EmitObjCKVCRefLValue(const ObjCKVCRefExpr *E) { 1176 // This is a special l-value that just issues sends when we load or 1177 // store through it. 1178 return LValue::MakeKVCRef(E, E->getType().getCVRQualifiers()); 1179} 1180 1181LValue 1182CodeGenFunction::EmitObjCSuperExpr(const ObjCSuperExpr *E) { 1183 return EmitUnsupportedLValue(E, "use of super"); 1184} 1185 1186RValue CodeGenFunction::EmitCallExpr(llvm::Value *Callee, QualType CalleeType, 1187 CallExpr::const_arg_iterator ArgBeg, 1188 CallExpr::const_arg_iterator ArgEnd, 1189 const Decl *TargetDecl) { 1190 // Get the actual function type. The callee type will always be a 1191 // pointer to function type or a block pointer type. 1192 assert(CalleeType->isFunctionPointerType() && 1193 "Call must have function pointer type!"); 1194 1195 QualType FnType = CalleeType->getAsPointerType()->getPointeeType(); 1196 QualType ResultType = FnType->getAsFunctionType()->getResultType(); 1197 1198 CallArgList Args; 1199 EmitCallArgs(Args, FnType->getAsFunctionProtoType(), ArgBeg, ArgEnd); 1200 1201 return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args), 1202 Callee, Args, TargetDecl); 1203} 1204