CGExpr.cpp revision 6ec3668a2608b63473207319f5ceff9bbd22ea51
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::VAArgExprClass: 141 return EmitVAArgExprLValue(cast<VAArgExpr>(E)); 142 case Expr::DeclRefExprClass: 143 case Expr::QualifiedDeclRefExprClass: 144 return EmitDeclRefLValue(cast<DeclRefExpr>(E)); 145 case Expr::ParenExprClass:return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 146 case Expr::PredefinedExprClass: 147 return EmitPredefinedLValue(cast<PredefinedExpr>(E)); 148 case Expr::StringLiteralClass: 149 return EmitStringLiteralLValue(cast<StringLiteral>(E)); 150 151 case Expr::CXXConditionDeclExprClass: 152 return EmitCXXConditionDeclLValue(cast<CXXConditionDeclExpr>(E)); 153 154 case Expr::ObjCMessageExprClass: 155 return EmitObjCMessageExprLValue(cast<ObjCMessageExpr>(E)); 156 case Expr::ObjCIvarRefExprClass: 157 return EmitObjCIvarRefLValue(cast<ObjCIvarRefExpr>(E)); 158 case Expr::ObjCPropertyRefExprClass: 159 return EmitObjCPropertyRefLValue(cast<ObjCPropertyRefExpr>(E)); 160 case Expr::ObjCKVCRefExprClass: 161 return EmitObjCKVCRefLValue(cast<ObjCKVCRefExpr>(E)); 162 case Expr::ObjCSuperExprClass: 163 return EmitObjCSuperExpr(cast<ObjCSuperExpr>(E)); 164 165 case Expr::UnaryOperatorClass: 166 return EmitUnaryOpLValue(cast<UnaryOperator>(E)); 167 case Expr::ArraySubscriptExprClass: 168 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E)); 169 case Expr::ExtVectorElementExprClass: 170 return EmitExtVectorElementExpr(cast<ExtVectorElementExpr>(E)); 171 case Expr::MemberExprClass: return EmitMemberExpr(cast<MemberExpr>(E)); 172 case Expr::CompoundLiteralExprClass: 173 return EmitCompoundLiteralLValue(cast<CompoundLiteralExpr>(E)); 174 case Expr::ChooseExprClass: 175 // __builtin_choose_expr is the lvalue of the selected operand. 176 if (cast<ChooseExpr>(E)->isConditionTrue(getContext())) 177 return EmitLValue(cast<ChooseExpr>(E)->getLHS()); 178 else 179 return EmitLValue(cast<ChooseExpr>(E)->getRHS()); 180 } 181} 182 183llvm::Value *CodeGenFunction::EmitLoadOfScalar(llvm::Value *Addr, bool Volatile, 184 QualType Ty) { 185 llvm::Value *V = Builder.CreateLoad(Addr, Volatile, "tmp"); 186 187 // Bool can have different representation in memory than in 188 // registers. 189 if (Ty->isBooleanType()) 190 if (V->getType() != llvm::Type::Int1Ty) 191 V = Builder.CreateTrunc(V, llvm::Type::Int1Ty, "tobool"); 192 193 return V; 194} 195 196void CodeGenFunction::EmitStoreOfScalar(llvm::Value *Value, llvm::Value *Addr, 197 bool Volatile) { 198 // Handle stores of types which have different representations in 199 // memory and as LLVM values. 200 201 // FIXME: We shouldn't be this loose, we should only do this 202 // conversion when we have a type we know has a different memory 203 // representation (e.g., bool). 204 205 const llvm::Type *SrcTy = Value->getType(); 206 const llvm::PointerType *DstPtr = cast<llvm::PointerType>(Addr->getType()); 207 if (DstPtr->getElementType() != SrcTy) { 208 const llvm::Type *MemTy = 209 llvm::PointerType::get(SrcTy, DstPtr->getAddressSpace()); 210 Addr = Builder.CreateBitCast(Addr, MemTy, "storetmp"); 211 } 212 213 Builder.CreateStore(Value, Addr, Volatile); 214} 215 216/// EmitLoadOfLValue - Given an expression that represents a value lvalue, 217/// this method emits the address of the lvalue, then loads the result as an 218/// rvalue, returning the rvalue. 219RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, QualType ExprType) { 220 if (LV.isObjCWeak()) { 221 // load of a __weak object. 222 llvm::Value *AddrWeakObj = LV.getAddress(); 223 llvm::Value *read_weak = CGM.getObjCRuntime().EmitObjCWeakRead(*this, 224 AddrWeakObj); 225 return RValue::get(read_weak); 226 } 227 228 if (LV.isSimple()) { 229 llvm::Value *Ptr = LV.getAddress(); 230 const llvm::Type *EltTy = 231 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 232 233 // Simple scalar l-value. 234 if (EltTy->isSingleValueType()) 235 return RValue::get(EmitLoadOfScalar(Ptr, LV.isVolatileQualified(), 236 ExprType)); 237 238 assert(ExprType->isFunctionType() && "Unknown scalar value"); 239 return RValue::get(Ptr); 240 } 241 242 if (LV.isVectorElt()) { 243 llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(), 244 LV.isVolatileQualified(), "tmp"); 245 return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(), 246 "vecext")); 247 } 248 249 // If this is a reference to a subset of the elements of a vector, either 250 // shuffle the input or extract/insert them as appropriate. 251 if (LV.isExtVectorElt()) 252 return EmitLoadOfExtVectorElementLValue(LV, ExprType); 253 254 if (LV.isBitfield()) 255 return EmitLoadOfBitfieldLValue(LV, ExprType); 256 257 if (LV.isPropertyRef()) 258 return EmitLoadOfPropertyRefLValue(LV, ExprType); 259 260 assert(LV.isKVCRef() && "Unknown LValue type!"); 261 return EmitLoadOfKVCRefLValue(LV, ExprType); 262} 263 264RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV, 265 QualType ExprType) { 266 unsigned StartBit = LV.getBitfieldStartBit(); 267 unsigned BitfieldSize = LV.getBitfieldSize(); 268 llvm::Value *Ptr = LV.getBitfieldAddr(); 269 270 const llvm::Type *EltTy = 271 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 272 unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy); 273 274 // In some cases the bitfield may straddle two memory locations. 275 // Currently we load the entire bitfield, then do the magic to 276 // sign-extend it if necessary. This results in somewhat more code 277 // than necessary for the common case (one load), since two shifts 278 // accomplish both the masking and sign extension. 279 unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit); 280 llvm::Value *Val = Builder.CreateLoad(Ptr, LV.isVolatileQualified(), "tmp"); 281 282 // Shift to proper location. 283 if (StartBit) 284 Val = Builder.CreateLShr(Val, llvm::ConstantInt::get(EltTy, StartBit), 285 "bf.lo"); 286 287 // Mask off unused bits. 288 llvm::Constant *LowMask = 289 llvm::ConstantInt::get(llvm::APInt::getLowBitsSet(EltTySize, LowBits)); 290 Val = Builder.CreateAnd(Val, LowMask, "bf.lo.cleared"); 291 292 // Fetch the high bits if necessary. 293 if (LowBits < BitfieldSize) { 294 unsigned HighBits = BitfieldSize - LowBits; 295 llvm::Value *HighPtr = 296 Builder.CreateGEP(Ptr, llvm::ConstantInt::get(llvm::Type::Int32Ty, 1), 297 "bf.ptr.hi"); 298 llvm::Value *HighVal = Builder.CreateLoad(HighPtr, 299 LV.isVolatileQualified(), 300 "tmp"); 301 302 // Mask off unused bits. 303 llvm::Constant *HighMask = 304 llvm::ConstantInt::get(llvm::APInt::getLowBitsSet(EltTySize, HighBits)); 305 HighVal = Builder.CreateAnd(HighVal, HighMask, "bf.lo.cleared"); 306 307 // Shift to proper location and or in to bitfield value. 308 HighVal = Builder.CreateShl(HighVal, 309 llvm::ConstantInt::get(EltTy, LowBits)); 310 Val = Builder.CreateOr(Val, HighVal, "bf.val"); 311 } 312 313 // Sign extend if necessary. 314 if (LV.isBitfieldSigned()) { 315 llvm::Value *ExtraBits = llvm::ConstantInt::get(EltTy, 316 EltTySize - BitfieldSize); 317 Val = Builder.CreateAShr(Builder.CreateShl(Val, ExtraBits), 318 ExtraBits, "bf.val.sext"); 319 } 320 321 // The bitfield type and the normal type differ when the storage sizes 322 // differ (currently just _Bool). 323 Val = Builder.CreateIntCast(Val, ConvertType(ExprType), false, "tmp"); 324 325 return RValue::get(Val); 326} 327 328RValue CodeGenFunction::EmitLoadOfPropertyRefLValue(LValue LV, 329 QualType ExprType) { 330 return EmitObjCPropertyGet(LV.getPropertyRefExpr()); 331} 332 333RValue CodeGenFunction::EmitLoadOfKVCRefLValue(LValue LV, 334 QualType ExprType) { 335 return EmitObjCPropertyGet(LV.getKVCRefExpr()); 336} 337 338// If this is a reference to a subset of the elements of a vector, create an 339// appropriate shufflevector. 340RValue CodeGenFunction::EmitLoadOfExtVectorElementLValue(LValue LV, 341 QualType ExprType) { 342 llvm::Value *Vec = Builder.CreateLoad(LV.getExtVectorAddr(), 343 LV.isVolatileQualified(), "tmp"); 344 345 const llvm::Constant *Elts = LV.getExtVectorElts(); 346 347 // If the result of the expression is a non-vector type, we must be 348 // extracting a single element. Just codegen as an extractelement. 349 const VectorType *ExprVT = ExprType->getAsVectorType(); 350 if (!ExprVT) { 351 unsigned InIdx = getAccessedFieldNo(0, Elts); 352 llvm::Value *Elt = llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx); 353 return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp")); 354 } 355 356 // Always use shuffle vector to try to retain the original program structure 357 unsigned NumResultElts = ExprVT->getNumElements(); 358 359 llvm::SmallVector<llvm::Constant*, 4> Mask; 360 for (unsigned i = 0; i != NumResultElts; ++i) { 361 unsigned InIdx = getAccessedFieldNo(i, Elts); 362 Mask.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx)); 363 } 364 365 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 366 Vec = Builder.CreateShuffleVector(Vec, 367 llvm::UndefValue::get(Vec->getType()), 368 MaskV, "tmp"); 369 return RValue::get(Vec); 370} 371 372 373 374/// EmitStoreThroughLValue - Store the specified rvalue into the specified 375/// lvalue, where both are guaranteed to the have the same type, and that type 376/// is 'Ty'. 377void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, 378 QualType Ty) { 379 if (!Dst.isSimple()) { 380 if (Dst.isVectorElt()) { 381 // Read/modify/write the vector, inserting the new element. 382 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(), 383 Dst.isVolatileQualified(), "tmp"); 384 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), 385 Dst.getVectorIdx(), "vecins"); 386 Builder.CreateStore(Vec, Dst.getVectorAddr(),Dst.isVolatileQualified()); 387 return; 388 } 389 390 // If this is an update of extended vector elements, insert them as 391 // appropriate. 392 if (Dst.isExtVectorElt()) 393 return EmitStoreThroughExtVectorComponentLValue(Src, Dst, Ty); 394 395 if (Dst.isBitfield()) 396 return EmitStoreThroughBitfieldLValue(Src, Dst, Ty); 397 398 if (Dst.isPropertyRef()) 399 return EmitStoreThroughPropertyRefLValue(Src, Dst, Ty); 400 401 if (Dst.isKVCRef()) 402 return EmitStoreThroughKVCRefLValue(Src, Dst, Ty); 403 404 assert(0 && "Unknown LValue type"); 405 } 406 407 if (Dst.isObjCWeak()) { 408 // load of a __weak object. 409 llvm::Value *LvalueDst = Dst.getAddress(); 410 llvm::Value *src = Src.getScalarVal(); 411 CGM.getObjCRuntime().EmitObjCWeakAssign(*this, src, LvalueDst); 412 return; 413 } 414 415 if (Dst.isObjCStrong()) { 416 // load of a __strong object. 417 llvm::Value *LvalueDst = Dst.getAddress(); 418 llvm::Value *src = Src.getScalarVal(); 419 if (Dst.isObjCIvar()) 420 CGM.getObjCRuntime().EmitObjCIvarAssign(*this, src, LvalueDst); 421 else 422 CGM.getObjCRuntime().EmitObjCGlobalAssign(*this, src, LvalueDst); 423 return; 424 } 425 426 assert(Src.isScalar() && "Can't emit an agg store with this method"); 427 EmitStoreOfScalar(Src.getScalarVal(), Dst.getAddress(), 428 Dst.isVolatileQualified()); 429} 430 431void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 432 QualType Ty, 433 llvm::Value **Result) { 434 unsigned StartBit = Dst.getBitfieldStartBit(); 435 unsigned BitfieldSize = Dst.getBitfieldSize(); 436 llvm::Value *Ptr = Dst.getBitfieldAddr(); 437 438 const llvm::Type *EltTy = 439 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 440 unsigned EltTySize = CGM.getTargetData().getTypeSizeInBits(EltTy); 441 442 // Get the new value, cast to the appropriate type and masked to 443 // exactly the size of the bit-field. 444 llvm::Value *SrcVal = Src.getScalarVal(); 445 llvm::Value *NewVal = Builder.CreateIntCast(SrcVal, EltTy, false, "tmp"); 446 llvm::Constant *Mask = 447 llvm::ConstantInt::get(llvm::APInt::getLowBitsSet(EltTySize, BitfieldSize)); 448 NewVal = Builder.CreateAnd(NewVal, Mask, "bf.value"); 449 450 // Return the new value of the bit-field, if requested. 451 if (Result) { 452 // Cast back to the proper type for result. 453 const llvm::Type *SrcTy = SrcVal->getType(); 454 llvm::Value *SrcTrunc = Builder.CreateIntCast(NewVal, SrcTy, false, 455 "bf.reload.val"); 456 457 // Sign extend if necessary. 458 if (Dst.isBitfieldSigned()) { 459 unsigned SrcTySize = CGM.getTargetData().getTypeSizeInBits(SrcTy); 460 llvm::Value *ExtraBits = llvm::ConstantInt::get(SrcTy, 461 SrcTySize - BitfieldSize); 462 SrcTrunc = Builder.CreateAShr(Builder.CreateShl(SrcTrunc, ExtraBits), 463 ExtraBits, "bf.reload.sext"); 464 } 465 466 *Result = SrcTrunc; 467 } 468 469 // In some cases the bitfield may straddle two memory locations. 470 // Emit the low part first and check to see if the high needs to be 471 // done. 472 unsigned LowBits = std::min(BitfieldSize, EltTySize - StartBit); 473 llvm::Value *LowVal = Builder.CreateLoad(Ptr, Dst.isVolatileQualified(), 474 "bf.prev.low"); 475 476 // Compute the mask for zero-ing the low part of this bitfield. 477 llvm::Constant *InvMask = 478 llvm::ConstantInt::get(~llvm::APInt::getBitsSet(EltTySize, StartBit, 479 StartBit + LowBits)); 480 481 // Compute the new low part as 482 // LowVal = (LowVal & InvMask) | (NewVal << StartBit), 483 // with the shift of NewVal implicitly stripping the high bits. 484 llvm::Value *NewLowVal = 485 Builder.CreateShl(NewVal, llvm::ConstantInt::get(EltTy, StartBit), 486 "bf.value.lo"); 487 LowVal = Builder.CreateAnd(LowVal, InvMask, "bf.prev.lo.cleared"); 488 LowVal = Builder.CreateOr(LowVal, NewLowVal, "bf.new.lo"); 489 490 // Write back. 491 Builder.CreateStore(LowVal, Ptr, Dst.isVolatileQualified()); 492 493 // If the low part doesn't cover the bitfield emit a high part. 494 if (LowBits < BitfieldSize) { 495 unsigned HighBits = BitfieldSize - LowBits; 496 llvm::Value *HighPtr = 497 Builder.CreateGEP(Ptr, llvm::ConstantInt::get(llvm::Type::Int32Ty, 1), 498 "bf.ptr.hi"); 499 llvm::Value *HighVal = Builder.CreateLoad(HighPtr, 500 Dst.isVolatileQualified(), 501 "bf.prev.hi"); 502 503 // Compute the mask for zero-ing the high part of this bitfield. 504 llvm::Constant *InvMask = 505 llvm::ConstantInt::get(~llvm::APInt::getLowBitsSet(EltTySize, HighBits)); 506 507 // Compute the new high part as 508 // HighVal = (HighVal & InvMask) | (NewVal lshr LowBits), 509 // where the high bits of NewVal have already been cleared and the 510 // shift stripping the low bits. 511 llvm::Value *NewHighVal = 512 Builder.CreateLShr(NewVal, llvm::ConstantInt::get(EltTy, LowBits), 513 "bf.value.high"); 514 HighVal = Builder.CreateAnd(HighVal, InvMask, "bf.prev.hi.cleared"); 515 HighVal = Builder.CreateOr(HighVal, NewHighVal, "bf.new.hi"); 516 517 // Write back. 518 Builder.CreateStore(HighVal, HighPtr, Dst.isVolatileQualified()); 519 } 520} 521 522void CodeGenFunction::EmitStoreThroughPropertyRefLValue(RValue Src, 523 LValue Dst, 524 QualType Ty) { 525 EmitObjCPropertySet(Dst.getPropertyRefExpr(), Src); 526} 527 528void CodeGenFunction::EmitStoreThroughKVCRefLValue(RValue Src, 529 LValue Dst, 530 QualType Ty) { 531 EmitObjCPropertySet(Dst.getKVCRefExpr(), Src); 532} 533 534void CodeGenFunction::EmitStoreThroughExtVectorComponentLValue(RValue Src, 535 LValue Dst, 536 QualType Ty) { 537 // This access turns into a read/modify/write of the vector. Load the input 538 // value now. 539 llvm::Value *Vec = Builder.CreateLoad(Dst.getExtVectorAddr(), 540 Dst.isVolatileQualified(), "tmp"); 541 const llvm::Constant *Elts = Dst.getExtVectorElts(); 542 543 llvm::Value *SrcVal = Src.getScalarVal(); 544 545 if (const VectorType *VTy = Ty->getAsVectorType()) { 546 unsigned NumSrcElts = VTy->getNumElements(); 547 unsigned NumDstElts = 548 cast<llvm::VectorType>(Vec->getType())->getNumElements(); 549 if (NumDstElts == NumSrcElts) { 550 // Use shuffle vector is the src and destination are the same number 551 // of elements 552 llvm::SmallVector<llvm::Constant*, 4> Mask; 553 for (unsigned i = 0; i != NumSrcElts; ++i) { 554 unsigned InIdx = getAccessedFieldNo(i, Elts); 555 Mask.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx)); 556 } 557 558 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 559 Vec = Builder.CreateShuffleVector(SrcVal, 560 llvm::UndefValue::get(Vec->getType()), 561 MaskV, "tmp"); 562 } 563 else if (NumDstElts > NumSrcElts) { 564 // Extended the source vector to the same length and then shuffle it 565 // into the destination. 566 // FIXME: since we're shuffling with undef, can we just use the indices 567 // into that? This could be simpler. 568 llvm::SmallVector<llvm::Constant*, 4> ExtMask; 569 unsigned i; 570 for (i = 0; i != NumSrcElts; ++i) 571 ExtMask.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, i)); 572 for (; i != NumDstElts; ++i) 573 ExtMask.push_back(llvm::UndefValue::get(llvm::Type::Int32Ty)); 574 llvm::Value *ExtMaskV = llvm::ConstantVector::get(&ExtMask[0], 575 ExtMask.size()); 576 llvm::Value *ExtSrcVal = 577 Builder.CreateShuffleVector(SrcVal, 578 llvm::UndefValue::get(SrcVal->getType()), 579 ExtMaskV, "tmp"); 580 // build identity 581 llvm::SmallVector<llvm::Constant*, 4> Mask; 582 for (unsigned i = 0; i != NumDstElts; ++i) { 583 Mask.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, i)); 584 } 585 // modify when what gets shuffled in 586 for (unsigned i = 0; i != NumSrcElts; ++i) { 587 unsigned Idx = getAccessedFieldNo(i, Elts); 588 Mask[Idx] =llvm::ConstantInt::get(llvm::Type::Int32Ty, i+NumDstElts); 589 } 590 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 591 Vec = Builder.CreateShuffleVector(Vec, ExtSrcVal, MaskV, "tmp"); 592 } 593 else { 594 // We should never shorten the vector 595 assert(0 && "unexpected shorten vector length"); 596 } 597 } else { 598 // If the Src is a scalar (not a vector) it must be updating one element. 599 unsigned InIdx = getAccessedFieldNo(0, Elts); 600 llvm::Value *Elt = llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx); 601 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp"); 602 } 603 604 Builder.CreateStore(Vec, Dst.getExtVectorAddr(), Dst.isVolatileQualified()); 605} 606 607/// SetDeclObjCGCAttrInLvalue - Set __weak/__strong attributes into the LValue 608/// object. 609static void SetDeclObjCGCAttrInLvalue(ASTContext &Ctx, const QualType &Ty, 610 LValue &LV) 611{ 612 QualType::GCAttrTypes attr = Ctx.getObjCGCAttrKind(Ty); 613 if (attr != QualType::GCNone) 614 LValue::SetObjCType(attr == QualType::Weak, 615 attr == QualType::Strong, LV); 616} 617 618LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { 619 const VarDecl *VD = dyn_cast<VarDecl>(E->getDecl()); 620 621 if (VD && (VD->isBlockVarDecl() || isa<ParmVarDecl>(VD) || 622 isa<ImplicitParamDecl>(VD))) { 623 LValue LV; 624 if (VD->getStorageClass() == VarDecl::Extern) { 625 LV = LValue::MakeAddr(CGM.GetAddrOfGlobalVar(VD), 626 E->getType().getCVRQualifiers()); 627 } 628 else { 629 llvm::Value *V = LocalDeclMap[VD]; 630 assert(V && "BlockVarDecl not entered in LocalDeclMap?"); 631 LV = LValue::MakeAddr(V, E->getType().getCVRQualifiers()); 632 } 633 if (VD->isBlockVarDecl() && 634 (VD->getStorageClass() == VarDecl::Static || 635 VD->getStorageClass() == VarDecl::Extern)) 636 SetDeclObjCGCAttrInLvalue(getContext(), E->getType(), LV); 637 return LV; 638 } else if (VD && VD->isFileVarDecl()) { 639 LValue LV = LValue::MakeAddr(CGM.GetAddrOfGlobalVar(VD), 640 E->getType().getCVRQualifiers()); 641 SetDeclObjCGCAttrInLvalue(getContext(), E->getType(), LV); 642 return LV; 643 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(E->getDecl())) { 644 return LValue::MakeAddr(CGM.GetAddrOfFunction(FD), 645 E->getType().getCVRQualifiers()); 646 } 647 else if (const ImplicitParamDecl *IPD = 648 dyn_cast<ImplicitParamDecl>(E->getDecl())) { 649 llvm::Value *V = LocalDeclMap[IPD]; 650 assert(V && "BlockVarDecl not entered in LocalDeclMap?"); 651 return LValue::MakeAddr(V, E->getType().getCVRQualifiers()); 652 } 653 assert(0 && "Unimp declref"); 654 //an invalid LValue, but the assert will 655 //ensure that this point is never reached. 656 return LValue(); 657} 658 659LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { 660 // __extension__ doesn't affect lvalue-ness. 661 if (E->getOpcode() == UnaryOperator::Extension) 662 return EmitLValue(E->getSubExpr()); 663 664 QualType ExprTy = getContext().getCanonicalType(E->getSubExpr()->getType()); 665 switch (E->getOpcode()) { 666 default: assert(0 && "Unknown unary operator lvalue!"); 667 case UnaryOperator::Deref: 668 return LValue::MakeAddr(EmitScalarExpr(E->getSubExpr()), 669 ExprTy->getAsPointerType()->getPointeeType() 670 .getCVRQualifiers()); 671 case UnaryOperator::Real: 672 case UnaryOperator::Imag: 673 LValue LV = EmitLValue(E->getSubExpr()); 674 unsigned Idx = E->getOpcode() == UnaryOperator::Imag; 675 return LValue::MakeAddr(Builder.CreateStructGEP(LV.getAddress(), 676 Idx, "idx"), 677 ExprTy.getCVRQualifiers()); 678 } 679} 680 681LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { 682 return LValue::MakeAddr(CGM.GetAddrOfConstantStringFromLiteral(E), 0); 683} 684 685LValue CodeGenFunction::EmitPredefinedFunctionName(unsigned Type) { 686 std::string GlobalVarName; 687 688 switch (Type) { 689 default: 690 assert(0 && "Invalid type"); 691 case PredefinedExpr::Func: 692 GlobalVarName = "__func__."; 693 break; 694 case PredefinedExpr::Function: 695 GlobalVarName = "__FUNCTION__."; 696 break; 697 case PredefinedExpr::PrettyFunction: 698 // FIXME:: Demangle C++ method names 699 GlobalVarName = "__PRETTY_FUNCTION__."; 700 break; 701 } 702 703 std::string FunctionName; 704 if(const FunctionDecl *FD = dyn_cast<FunctionDecl>(CurFuncDecl)) { 705 FunctionName = CGM.getMangledName(FD); 706 } else { 707 // Just get the mangled name. 708 FunctionName = CurFn->getName(); 709 } 710 711 GlobalVarName += FunctionName; 712 llvm::Constant *C = 713 CGM.GetAddrOfConstantCString(FunctionName, GlobalVarName.c_str()); 714 return LValue::MakeAddr(C, 0); 715} 716 717LValue CodeGenFunction::EmitPredefinedLValue(const PredefinedExpr *E) { 718 switch (E->getIdentType()) { 719 default: 720 return EmitUnsupportedLValue(E, "predefined expression"); 721 case PredefinedExpr::Func: 722 case PredefinedExpr::Function: 723 case PredefinedExpr::PrettyFunction: 724 return EmitPredefinedFunctionName(E->getIdentType()); 725 } 726} 727 728LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { 729 // The index must always be an integer, which is not an aggregate. Emit it. 730 llvm::Value *Idx = EmitScalarExpr(E->getIdx()); 731 732 // If the base is a vector type, then we are forming a vector element lvalue 733 // with this subscript. 734 if (E->getBase()->getType()->isVectorType()) { 735 // Emit the vector as an lvalue to get its address. 736 LValue LHS = EmitLValue(E->getBase()); 737 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 738 // FIXME: This should properly sign/zero/extend or truncate Idx to i32. 739 return LValue::MakeVectorElt(LHS.getAddress(), Idx, 740 E->getBase()->getType().getCVRQualifiers()); 741 } 742 743 // The base must be a pointer, which is not an aggregate. Emit it. 744 llvm::Value *Base = EmitScalarExpr(E->getBase()); 745 746 // Extend or truncate the index type to 32 or 64-bits. 747 QualType IdxTy = E->getIdx()->getType(); 748 bool IdxSigned = IdxTy->isSignedIntegerType(); 749 unsigned IdxBitwidth = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 750 if (IdxBitwidth != LLVMPointerWidth) 751 Idx = Builder.CreateIntCast(Idx, llvm::IntegerType::get(LLVMPointerWidth), 752 IdxSigned, "idxprom"); 753 754 // We know that the pointer points to a type of the correct size, unless the 755 // size is a VLA. 756 if (const VariableArrayType *VAT = 757 getContext().getAsVariableArrayType(E->getType())) { 758 llvm::Value *VLASize = VLASizeMap[VAT]; 759 760 Idx = Builder.CreateMul(Idx, VLASize); 761 762 QualType BaseType = getContext().getBaseElementType(VAT); 763 764 uint64_t BaseTypeSize = getContext().getTypeSize(BaseType) / 8; 765 Idx = Builder.CreateUDiv(Idx, 766 llvm::ConstantInt::get(Idx->getType(), 767 BaseTypeSize)); 768 } 769 770 QualType ExprTy = getContext().getCanonicalType(E->getBase()->getType()); 771 772 return LValue::MakeAddr(Builder.CreateGEP(Base, Idx, "arrayidx"), 773 ExprTy->getAsPointerType()->getPointeeType() 774 .getCVRQualifiers()); 775} 776 777static 778llvm::Constant *GenerateConstantVector(llvm::SmallVector<unsigned, 4> &Elts) { 779 llvm::SmallVector<llvm::Constant *, 4> CElts; 780 781 for (unsigned i = 0, e = Elts.size(); i != e; ++i) 782 CElts.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, Elts[i])); 783 784 return llvm::ConstantVector::get(&CElts[0], CElts.size()); 785} 786 787LValue CodeGenFunction:: 788EmitExtVectorElementExpr(const ExtVectorElementExpr *E) { 789 // Emit the base vector as an l-value. 790 LValue Base; 791 792 // ExtVectorElementExpr's base can either be a vector or pointer to vector. 793 if (!E->isArrow()) { 794 assert(E->getBase()->getType()->isVectorType()); 795 Base = EmitLValue(E->getBase()); 796 } else { 797 const PointerType *PT = E->getBase()->getType()->getAsPointerType(); 798 llvm::Value *Ptr = EmitScalarExpr(E->getBase()); 799 Base = LValue::MakeAddr(Ptr, PT->getPointeeType().getCVRQualifiers()); 800 } 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 Base.getQualifiers()); 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 Base.getQualifiers()); 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 } else if (isa<ObjCPropertyRefExpr>(BaseExpr) || 843 isa<ObjCKVCRefExpr>(BaseExpr)) { 844 RValue RV = EmitObjCPropertyGet(BaseExpr); 845 BaseValue = RV.getAggregateAddr(); 846 if (BaseExpr->getType()->isUnionType()) 847 isUnion = true; 848 CVRQualifiers = BaseExpr->getType().getCVRQualifiers(); 849 } else { 850 LValue BaseLV = EmitLValue(BaseExpr); 851 if (BaseLV.isObjCIvar()) 852 isIvar = true; 853 // FIXME: this isn't right for bitfields. 854 BaseValue = BaseLV.getAddress(); 855 if (BaseExpr->getType()->isUnionType()) 856 isUnion = true; 857 CVRQualifiers = BaseExpr->getType().getCVRQualifiers(); 858 } 859 860 FieldDecl *Field = dyn_cast<FieldDecl>(E->getMemberDecl()); 861 // FIXME: Handle non-field member expressions 862 assert(Field && "No code generation for non-field member references"); 863 LValue MemExpLV = EmitLValueForField(BaseValue, Field, isUnion, 864 CVRQualifiers); 865 LValue::SetObjCIvar(MemExpLV, isIvar); 866 return MemExpLV; 867} 868 869LValue CodeGenFunction::EmitLValueForBitfield(llvm::Value* BaseValue, 870 FieldDecl* Field, 871 unsigned CVRQualifiers) { 872 unsigned idx = CGM.getTypes().getLLVMFieldNo(Field); 873 // FIXME: CodeGenTypes should expose a method to get the appropriate 874 // type for FieldTy (the appropriate type is ABI-dependent). 875 const llvm::Type *FieldTy = 876 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 (CGM.getLangOptions().ObjC1 && 921 CGM.getLangOptions().getGCMode() != LangOptions::NonGC) { 922 QualType Ty = Field->getType(); 923 QualType::GCAttrTypes attr = Ty.getObjCGCAttr(); 924 if (attr != QualType::GCNone) 925 // __weak attribute on a field is ignored. 926 LValue::SetObjCType(false, attr == QualType::Strong, LV); 927 else if (getContext().isObjCObjectPointerType(Ty)) 928 LValue::SetObjCType(false, true, LV); 929 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->getBuiltinID(getContext())) 966 return EmitBuiltinExpr(FDecl, builtinID, E); 967 968 if (E->getCallee()->getType()->isBlockPointerType()) 969 return EmitBlockCallExpr(E); 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 return LValue::MakeAddr(RV.getAggregateAddr(), 1000 E->getType().getCVRQualifiers()); 1001} 1002 1003LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) { 1004 // FIXME: This shouldn't require another copy. 1005 llvm::Value *Temp = CreateTempAlloca(ConvertType(E->getType())); 1006 EmitAggExpr(E, Temp, false); 1007 return LValue::MakeAddr(Temp, E->getType().getCVRQualifiers()); 1008} 1009 1010LValue 1011CodeGenFunction::EmitCXXConditionDeclLValue(const CXXConditionDeclExpr *E) { 1012 EmitLocalBlockVarDecl(*E->getVarDecl()); 1013 return EmitDeclRefLValue(E); 1014} 1015 1016LValue CodeGenFunction::EmitObjCMessageExprLValue(const ObjCMessageExpr *E) { 1017 // Can only get l-value for message expression returning aggregate type 1018 RValue RV = EmitObjCMessageExpr(E); 1019 // FIXME: can this be volatile? 1020 return LValue::MakeAddr(RV.getAggregateAddr(), 1021 E->getType().getCVRQualifiers()); 1022} 1023 1024llvm::Value *CodeGenFunction::EmitIvarOffset(ObjCInterfaceDecl *Interface, 1025 const ObjCIvarDecl *Ivar) { 1026 // Objective-C objects are traditionally C structures with their layout 1027 // defined at compile-time. In some implementations, their layout is not 1028 // defined until run time in order to allow instance variables to be added to 1029 // a class without recompiling all of the subclasses. If this is the case 1030 // then the CGObjCRuntime subclass must return true to LateBoundIvars and 1031 // implement the lookup itself. 1032 if (CGM.getObjCRuntime().LateBoundIVars()) 1033 assert(0 && "late-bound ivars are unsupported"); 1034 return CGM.getObjCRuntime().EmitIvarOffset(*this, Interface, Ivar); 1035} 1036 1037LValue CodeGenFunction::EmitLValueForIvar(QualType ObjectTy, 1038 llvm::Value *BaseValue, 1039 const ObjCIvarDecl *Ivar, 1040 const FieldDecl *Field, 1041 unsigned CVRQualifiers) { 1042 // See comment in EmitIvarOffset. 1043 if (CGM.getObjCRuntime().LateBoundIVars()) 1044 assert(0 && "late-bound ivars are unsupported"); 1045 1046 LValue LV = CGM.getObjCRuntime().EmitObjCValueForIvar(*this, 1047 ObjectTy, 1048 BaseValue, Ivar, Field, 1049 CVRQualifiers); 1050 SetDeclObjCGCAttrInLvalue(getContext(), Ivar->getType(), LV); 1051 return LV; 1052} 1053 1054LValue CodeGenFunction::EmitObjCIvarRefLValue(const ObjCIvarRefExpr *E) { 1055 // FIXME: A lot of the code below could be shared with EmitMemberExpr. 1056 llvm::Value *BaseValue = 0; 1057 const Expr *BaseExpr = E->getBase(); 1058 unsigned CVRQualifiers = 0; 1059 QualType ObjectTy; 1060 if (E->isArrow()) { 1061 BaseValue = EmitScalarExpr(BaseExpr); 1062 const PointerType *PTy = 1063 cast<PointerType>(getContext().getCanonicalType(BaseExpr->getType())); 1064 ObjectTy = PTy->getPointeeType(); 1065 CVRQualifiers = ObjectTy.getCVRQualifiers(); 1066 } else { 1067 LValue BaseLV = EmitLValue(BaseExpr); 1068 // FIXME: this isn't right for bitfields. 1069 BaseValue = BaseLV.getAddress(); 1070 ObjectTy = BaseExpr->getType(); 1071 CVRQualifiers = ObjectTy.getCVRQualifiers(); 1072 } 1073 1074 return EmitLValueForIvar(ObjectTy, BaseValue, E->getDecl(), 1075 getContext().getFieldDecl(E), CVRQualifiers); 1076} 1077 1078LValue 1079CodeGenFunction::EmitObjCPropertyRefLValue(const ObjCPropertyRefExpr *E) { 1080 // This is a special l-value that just issues sends when we load or 1081 // store through it. 1082 return LValue::MakePropertyRef(E, E->getType().getCVRQualifiers()); 1083} 1084 1085LValue 1086CodeGenFunction::EmitObjCKVCRefLValue(const ObjCKVCRefExpr *E) { 1087 // This is a special l-value that just issues sends when we load or 1088 // store through it. 1089 return LValue::MakeKVCRef(E, E->getType().getCVRQualifiers()); 1090} 1091 1092LValue 1093CodeGenFunction::EmitObjCSuperExpr(const ObjCSuperExpr *E) { 1094 return EmitUnsupportedLValue(E, "use of super"); 1095} 1096 1097RValue CodeGenFunction::EmitCallExpr(llvm::Value *Callee, QualType CalleeType, 1098 CallExpr::const_arg_iterator ArgBeg, 1099 CallExpr::const_arg_iterator ArgEnd) { 1100 // Get the actual function type. The callee type will always be a 1101 // pointer to function type or a block pointer type. 1102 QualType ResultType; 1103 if (const BlockPointerType *BPT = dyn_cast<BlockPointerType>(CalleeType)) { 1104 ResultType = BPT->getPointeeType()->getAsFunctionType()->getResultType(); 1105 } else { 1106 assert(CalleeType->isFunctionPointerType() && 1107 "Call must have function pointer type!"); 1108 QualType FnType = CalleeType->getAsPointerType()->getPointeeType(); 1109 ResultType = FnType->getAsFunctionType()->getResultType(); 1110 } 1111 1112 CallArgList Args; 1113 for (CallExpr::const_arg_iterator I = ArgBeg; I != ArgEnd; ++I) 1114 Args.push_back(std::make_pair(EmitAnyExprToTemp(*I), 1115 I->getType())); 1116 1117 return EmitCall(CGM.getTypes().getFunctionInfo(ResultType, Args), 1118 Callee, Args); 1119} 1120