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