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