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