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