CGExpr.cpp revision b14095aa98c6fedd3625920c4ce834bcaf24d9f7
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 std::string FunctionName; 756 if(const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurFuncDecl)) { 757 FunctionName = CGM.getMangledName(FD); 758 } else { 759 // Just get the mangled name; skipping the asm prefix if it 760 // exists. 761 FunctionName = CurFn->getName(); 762 if (FunctionName[0] == '\01') 763 FunctionName = FunctionName.substr(1, std::string::npos); 764 } 765 766 GlobalVarName += FunctionName; 767 llvm::Constant *C = 768 CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str()); 769 return LValue::MakeAddr(C, 0); 770} 771 772LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { 773 switch (E->getIdentType()) { 774 default: 775 return EmitUnsupportedLValue(E, "predefined expression"); 776 case PredefinedExpr::Func: 777 case PredefinedExpr::Function: 778 case PredefinedExpr::PrettyFunction: 779 return EmitPredefinedFunctionName(E->getIdentType()); 780 } 781} 782 783LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { 784 // The index must always be an integer, which is not an aggregate. Emit it. 785 llvm::Value *Idx = EmitScalarExpr(E->getIdx()); 786 787 // If the base is a vector type, then we are forming a vector element lvalue 788 // with this subscript. 789 if (E->getBase()->getType()->isVectorType()) { 790 // Emit the vector as an lvalue to get its address. 791 LValue LHS = EmitLValue(E->getBase()); 792 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 793 // FIXME: This should properly sign/zero/extend or truncate Idx to i32. 794 return LValue::MakeVectorElt(LHS.getAddress(), Idx, 795 E->getBase()->getType().getCVRQualifiers()); 796 } 797 798 // The base must be a pointer, which is not an aggregate. Emit it. 799 llvm::Value *Base = EmitScalarExpr(E->getBase()); 800 801 // Extend or truncate the index type to 32 or 64-bits. 802 QualType IdxTy = E->getIdx()->getType(); 803 bool IdxSigned = IdxTy->isSignedIntegerType(); 804 unsigned IdxBitwidth = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 805 806 // If Pointer width is less than 32 than extend to 32. 807 unsigned IdxValidWidth = (LLVMPointerWidth < 32 ) ? 32 : LLVMPointerWidth; 808 if (IdxBitwidth != IdxValidWidth) 809 Idx = Builder.CreateIntCast(Idx, llvm::IntegerType::get(IdxValidWidth), 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(); 829 QualType ExprTy = getContext().getCanonicalType(T); 830 T = T->getAsPointerType()->getPointeeType(); 831 LValue LV = 832 LValue::MakeAddr(Builder.CreateGEP(Base, Idx, "arrayidx"), 833 ExprTy->getAsPointerType()->getPointeeType().getCVRQualifiers(), 834 getContext().getObjCGCAttrKind(T)); 835 if (getContext().getLangOptions().ObjC1 && 836 getContext().getLangOptions().getGCMode() != LangOptions::NonGC) 837 LValue::SetObjCNonGC(LV, !E->isOBJCGCCandidate()); 838 return LV; 839} 840 841static 842llvm::Constant *GenerateConstantVector(llvm::SmallVector<unsigned, 4> &Elts) { 843 llvm::SmallVector<llvm::Constant *, 4> CElts; 844 845 for (unsigned i = 0, e = Elts.size(); i != e; ++i) 846 CElts.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, Elts[i])); 847 848 return llvm::ConstantVector::get(&CElts[0], CElts.size()); 849} 850 851LValue CodeGenFunction:: 852EmitExtVectorElementExpr(const ExtVectorElementExpr *E) { 853 // Emit the base vector as an l-value. 854 LValue Base; 855 856 // ExtVectorElementExpr's base can either be a vector or pointer to vector. 857 if (!E->isArrow()) { 858 assert(E->getBase()->getType()->isVectorType()); 859 Base = EmitLValue(E->getBase()); 860 } else { 861 const PointerType *PT = E->getBase()->getType()->getAsPointerType(); 862 llvm::Value *Ptr = EmitScalarExpr(E->getBase()); 863 Base = LValue::MakeAddr(Ptr, PT->getPointeeType().getCVRQualifiers()); 864 } 865 866 // Encode the element access list into a vector of unsigned indices. 867 llvm::SmallVector<unsigned, 4> Indices; 868 E->getEncodedElementAccess(Indices); 869 870 if (Base.isSimple()) { 871 llvm::Constant *CV = GenerateConstantVector(Indices); 872 return LValue::MakeExtVectorElt(Base.getAddress(), CV, 873 Base.getQualifiers()); 874 } 875 assert(Base.isExtVectorElt() && "Can only subscript lvalue vec elts here!"); 876 877 llvm::Constant *BaseElts = Base.getExtVectorElts(); 878 llvm::SmallVector<llvm::Constant *, 4> CElts; 879 880 for (unsigned i = 0, e = Indices.size(); i != e; ++i) { 881 if (isa<llvm::ConstantAggregateZero>(BaseElts)) 882 CElts.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, 0)); 883 else 884 CElts.push_back(BaseElts->getOperand(Indices[i])); 885 } 886 llvm::Constant *CV = llvm::ConstantVector::get(&CElts[0], CElts.size()); 887 return LValue::MakeExtVectorElt(Base.getExtVectorAddr(), CV, 888 Base.getQualifiers()); 889} 890 891LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { 892 bool isUnion = false; 893 bool isIvar = false; 894 bool isNonGC = false; 895 Expr *BaseExpr = E->getBase(); 896 llvm::Value *BaseValue = NULL; 897 unsigned CVRQualifiers=0; 898 899 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 900 if (E->isArrow()) { 901 BaseValue = EmitScalarExpr(BaseExpr); 902 const PointerType *PTy = 903 cast<PointerType>(getContext().getCanonicalType(BaseExpr->getType())); 904 if (PTy->getPointeeType()->isUnionType()) 905 isUnion = true; 906 CVRQualifiers = PTy->getPointeeType().getCVRQualifiers(); 907 } else if (isa<ObjCPropertyRefExpr>(BaseExpr) || 908 isa<ObjCKVCRefExpr>(BaseExpr)) { 909 RValue RV = EmitObjCPropertyGet(BaseExpr); 910 BaseValue = RV.getAggregateAddr(); 911 if (BaseExpr->getType()->isUnionType()) 912 isUnion = true; 913 CVRQualifiers = BaseExpr->getType().getCVRQualifiers(); 914 } else { 915 LValue BaseLV = EmitLValue(BaseExpr); 916 if (BaseLV.isObjCIvar()) 917 isIvar = true; 918 if (BaseLV.isNonGC()) 919 isNonGC = true; 920 // FIXME: this isn't right for bitfields. 921 BaseValue = BaseLV.getAddress(); 922 if (BaseExpr->getType()->isUnionType()) 923 isUnion = true; 924 CVRQualifiers = BaseExpr->getType().getCVRQualifiers(); 925 } 926 927 FieldDecl *Field = dyn_cast<FieldDecl>(E->getMemberDecl()); 928 // FIXME: Handle non-field member expressions 929 assert(Field && "No code generation for non-field member references"); 930 LValue MemExpLV = EmitLValueForField(BaseValue, Field, isUnion, 931 CVRQualifiers); 932 LValue::SetObjCIvar(MemExpLV, isIvar); 933 LValue::SetObjCNonGC(MemExpLV, isNonGC); 934 return MemExpLV; 935} 936 937LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value* BaseValue, 938 FieldDecl* Field, 939 unsigned CVRQualifiers) { 940 unsigned idx = CGM.getTypes().getLLVMFieldNo(Field); 941 // FIXME: CodeGenTypes should expose a method to get the appropriate 942 // type for FieldTy (the appropriate type is ABI-dependent). 943 const llvm::Type *FieldTy = 944 CGM.getTypes().ConvertTypeForMem(Field->getType()); 945 const llvm::PointerType *BaseTy = 946 cast<llvm::PointerType>(BaseValue->getType()); 947 unsigned AS = BaseTy->getAddressSpace(); 948 BaseValue = Builder.CreateBitCast(BaseValue, 949 llvm::PointerType::get(FieldTy, AS), 950 "tmp"); 951 llvm::Value *V = Builder.CreateGEP(BaseValue, 952 llvm::ConstantInt::get(llvm::Type::Int32Ty, idx), 953 "tmp"); 954 955 CodeGenTypes::BitFieldInfo bitFieldInfo = 956 CGM.getTypes().getBitFieldInfo(Field); 957 return LValue::MakeBitfield(V, bitFieldInfo.Begin, bitFieldInfo.Size, 958 Field->getType()->isSignedIntegerType(), 959 Field->getType().getCVRQualifiers()|CVRQualifiers); 960} 961 962LValue CodeGenFunction::EmitLValueForField(llvm::Value* BaseValue, 963 FieldDecl* Field, 964 bool isUnion, 965 unsigned CVRQualifiers) 966{ 967 if (Field->isBitField()) 968 return EmitLValueForBitfield(BaseValue, Field, CVRQualifiers); 969 970 unsigned idx = CGM.getTypes().getLLVMFieldNo(Field); 971 llvm::Value *V = Builder.CreateStructGEP(BaseValue, idx, "tmp"); 972 973 // Match union field type. 974 if (isUnion) { 975 const llvm::Type *FieldTy = 976 CGM.getTypes().ConvertTypeForMem(Field->getType()); 977 const llvm::PointerType * BaseTy = 978 cast<llvm::PointerType>(BaseValue->getType()); 979 unsigned AS = BaseTy->getAddressSpace(); 980 V = Builder.CreateBitCast(V, 981 llvm::PointerType::get(FieldTy, AS), 982 "tmp"); 983 } 984 985 QualType::GCAttrTypes attr = QualType::GCNone; 986 if (CGM.getLangOptions().ObjC1 && 987 CGM.getLangOptions().getGCMode() != LangOptions::NonGC) { 988 QualType Ty = Field->getType(); 989 attr = Ty.getObjCGCAttr(); 990 if (attr != QualType::GCNone) { 991 // __weak attribute on a field is ignored. 992 if (attr == QualType::Weak) 993 attr = QualType::GCNone; 994 } 995 else if (getContext().isObjCObjectPointerType(Ty)) 996 attr = QualType::Strong; 997 } 998 LValue LV = 999 LValue::MakeAddr(V, 1000 Field->getType().getCVRQualifiers()|CVRQualifiers, 1001 attr); 1002 return LV; 1003} 1004 1005LValue CodeGenFunction::EmitCompoundLiteralLValue(const CompoundLiteralExpr* E){ 1006 const llvm::Type *LTy = ConvertType(E->getType()); 1007 llvm::Value *DeclPtr = CreateTempAlloca(LTy, ".compoundliteral"); 1008 1009 const Expr* InitExpr = E->getInitializer(); 1010 LValue Result = LValue::MakeAddr(DeclPtr, E->getType().getCVRQualifiers()); 1011 1012 if (E->getType()->isComplexType()) { 1013 EmitComplexExprIntoAddr(InitExpr, DeclPtr, false); 1014 } else if (hasAggregateLLVMType(E->getType())) { 1015 EmitAnyExpr(InitExpr, DeclPtr, false); 1016 } else { 1017 EmitStoreThroughLValue(EmitAnyExpr(InitExpr), Result, E->getType()); 1018 } 1019 1020 return Result; 1021} 1022 1023LValue CodeGenFunction::EmitConditionalOperator(const ConditionalOperator* E) { 1024 // We don't handle vectors yet. 1025 if (E->getType()->isVectorType()) 1026 return EmitUnsupportedLValue(E, "conditional operator"); 1027 1028 // ?: here should be an aggregate. 1029 assert((hasAggregateLLVMType(E->getType()) && 1030 !E->getType()->isAnyComplexType()) && 1031 "Unexpected conditional operator!"); 1032 1033 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1034 EmitAggExpr(E, Temp, false); 1035 1036 return LValue::MakeAddr(Temp, E->getType().getCVRQualifiers(), 1037 getContext().getObjCGCAttrKind(E->getType())); 1038 1039} 1040 1041/// EmitCastLValue - Casts are never lvalues. If a cast is needed by the code 1042/// generator in an lvalue context, then it must mean that we need the address 1043/// of an aggregate in order to access one of its fields. This can happen for 1044/// all the reasons that casts are permitted with aggregate result, including 1045/// noop aggregate casts, and cast from scalar to union. 1046LValue CodeGenFunction::EmitCastLValue(const CastExpr *E) { 1047 // If this is an aggregate-to-aggregate cast, just use the input's address as 1048 // the lvalue. 1049 if (getContext().hasSameUnqualifiedType(E->getType(), 1050 E->getSubExpr()->getType())) 1051 return EmitLValue(E->getSubExpr()); 1052 1053 // Otherwise, we must have a cast from scalar to union. 1054 assert(E->getType()->isUnionType() && "Expected scalar-to-union cast"); 1055 1056 // Casts are only lvalues when the source and destination types are the same. 1057 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1058 EmitAnyExpr(E->getSubExpr(), Temp, false); 1059 1060 return LValue::MakeAddr(Temp, E->getType().getCVRQualifiers(), 1061 getContext().getObjCGCAttrKind(E->getType())); 1062} 1063 1064//===--------------------------------------------------------------------===// 1065// Expression Emission 1066//===--------------------------------------------------------------------===// 1067 1068 1069RValue CodeGenFunction::EmitCallExpr(const CallExpr *E) { 1070 // Builtins never have block type. 1071 if (E->getCallee()->getType()->isBlockPointerType()) 1072 return EmitBlockCallExpr(E); 1073 1074 if (const CXXMemberCallExpr *CE = dyn_cast<CXXMemberCallExpr>(E)) 1075 return EmitCXXMemberCallExpr(CE); 1076 1077 const Decl *TargetDecl = 0; 1078 if (const ImplicitCastExpr *CE = dyn_cast<ImplicitCastExpr>(E->getCallee())) { 1079 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(CE->getSubExpr())) { 1080 TargetDecl = DRE->getDecl(); 1081 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(TargetDecl)) 1082 if (unsigned builtinID = FD->getBuiltinID(getContext())) 1083 return EmitBuiltinExpr(FD, builtinID, E); 1084 } 1085 } 1086 1087 llvm::Value *Callee = EmitScalarExpr(E->getCallee()); 1088 return EmitCallExpr(Callee, E->getCallee()->getType(), 1089 E->arg_begin(), E->arg_end(), TargetDecl); 1090} 1091 1092LValue CodeGenFunction::EmitBinaryOperatorLValue(const BinaryOperator *E) { 1093 // Can only get l-value for binary operator expressions which are a 1094 // simple assignment of aggregate type. 1095 if (E->getOpcode() != BinaryOperator::Assign) 1096 return EmitUnsupportedLValue(E, "binary l-value expression"); 1097 1098 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1099 EmitAggExpr(E, Temp, false); 1100 // FIXME: Are these qualifiers correct? 1101 return LValue::MakeAddr(Temp, E->getType().getCVRQualifiers(), 1102 getContext().getObjCGCAttrKind(E->getType())); 1103} 1104 1105LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) { 1106 // Can only get l-value for call expression returning aggregate type 1107 RValue RV = EmitCallExpr(E); 1108 return LValue::MakeAddr(RV.getAggregateAddr(), 1109 E->getType().getCVRQualifiers(), 1110 getContext().getObjCGCAttrKind(E->getType())); 1111} 1112 1113LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) { 1114 // FIXME: This shouldn't require another copy. 1115 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1116 EmitAggExpr(E, Temp, false); 1117 return LValue::MakeAddr(Temp, E->getType().getCVRQualifiers()); 1118} 1119 1120LValue 1121CodeGenFunction::EmitCXXConditionDeclLValue(const CXXConditionDeclExpr *E) { 1122 EmitLocalBlockVarDecl(*E->getVarDecl()); 1123 return EmitDeclRefLValue(E); 1124} 1125 1126LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) { 1127 // Can only get l-value for message expression returning aggregate type 1128 RValue RV = EmitObjCMessageExpr(E); 1129 // FIXME: can this be volatile? 1130 return LValue::MakeAddr(RV.getAggregateAddr(), 1131 E->getType().getCVRQualifiers(), 1132 getContext().getObjCGCAttrKind(E->getType())); 1133} 1134 1135llvm::Value *CodeGenFunction::EmitIvarOffset(ObjCInterfaceDecl *Interface, 1136 const ObjCIvarDecl *Ivar) { 1137 // Objective-C objects are traditionally C structures with their layout 1138 // defined at compile-time. In some implementations, their layout is not 1139 // defined until run time in order to allow instance variables to be added to 1140 // a class without recompiling all of the subclasses. If this is the case 1141 // then the CGObjCRuntime subclass must return true to LateBoundIvars and 1142 // implement the lookup itself. 1143 if (CGM.getObjCRuntime().LateBoundIVars()) 1144 assert(0 && "late-bound ivars are unsupported"); 1145 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar); 1146} 1147 1148LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy, 1149 llvm::Value *BaseValue, 1150 const ObjCIvarDecl *Ivar, 1151 const FieldDecl *Field, 1152 unsigned CVRQualifiers) { 1153 // See comment in EmitIvarOffset. 1154 if (CGM.getObjCRuntime().LateBoundIVars()) 1155 assert(0 && "late-bound ivars are unsupported"); 1156 1157 LValue LV = CGM.getObjCRuntime().EmitObjCValueForIvar(*this, 1158 ObjectTy, 1159 BaseValue, Ivar, Field, 1160 CVRQualifiers); 1161 return LV; 1162} 1163 1164LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) { 1165 // FIXME: A lot of the code below could be shared with EmitMemberExpr. 1166 llvm::Value *BaseValue = 0; 1167 const Expr *BaseExpr = E->getBase(); 1168 unsigned CVRQualifiers = 0; 1169 QualType ObjectTy; 1170 if (E->isArrow()) { 1171 BaseValue = EmitScalarExpr(BaseExpr); 1172 const PointerType *PTy = 1173 cast<PointerType>(getContext().getCanonicalType(BaseExpr->getType())); 1174 ObjectTy = PTy->getPointeeType(); 1175 CVRQualifiers = ObjectTy.getCVRQualifiers(); 1176 } else { 1177 LValue BaseLV = EmitLValue(BaseExpr); 1178 // FIXME: this isn't right for bitfields. 1179 BaseValue = BaseLV.getAddress(); 1180 ObjectTy = BaseExpr->getType(); 1181 CVRQualifiers = ObjectTy.getCVRQualifiers(); 1182 } 1183 1184 return EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(), 1185 getContext().getFieldDecl(E), CVRQualifiers); 1186} 1187 1188LValue 1189CodeGenFunction::EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E) { 1190 // This is a special l-value that just issues sends when we load or 1191 // store through it. 1192 return LValue::MakePropertyRef(E, E->getType().getCVRQualifiers()); 1193} 1194 1195LValue 1196CodeGenFunction::EmitObjCKVCRefLValue(const ObjCKVCRefExpr *E) { 1197 // This is a special l-value that just issues sends when we load or 1198 // store through it. 1199 return LValue::MakeKVCRef(E, E->getType().getCVRQualifiers()); 1200} 1201 1202LValue 1203CodeGenFunction::EmitObjCSuperExpr(const ObjCSuperExpr *E) { 1204 return EmitUnsupportedLValue(E, "use of super"); 1205} 1206 1207RValue CodeGenFunction::EmitCallExpr(llvm::Value *Callee, QualType CalleeType, 1208 CallExpr::const_arg_iterator ArgBeg, 1209 CallExpr::const_arg_iterator ArgEnd, 1210 const Decl *TargetDecl) { 1211 // Get the actual function type. The callee type will always be a 1212 // pointer to function type or a block pointer type. 1213 assert(CalleeType->isFunctionPointerType() && 1214 "Call must have function pointer type!"); 1215 1216 QualType FnType = CalleeType->getAsPointerType()->getPointeeType(); 1217 QualType ResultType = FnType->getAsFunctionType()->getResultType(); 1218 1219 CallArgList Args; 1220 EmitCallArgs(Args, FnType->getAsFunctionProtoType(), ArgBeg, ArgEnd); 1221 1222 return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args), 1223 Callee, Args, TargetDecl); 1224} 1225