CGExpr.cpp revision bda0b626e74513950405c27525af87e214e605e2
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 "clang/AST/AST.h" 17#include "llvm/Constants.h" 18#include "llvm/DerivedTypes.h" 19#include "llvm/Function.h" 20#include "llvm/GlobalVariable.h" 21#include "llvm/Support/MathExtras.h" 22using namespace clang; 23using namespace CodeGen; 24 25//===--------------------------------------------------------------------===// 26// Miscellaneous Helper Methods 27//===--------------------------------------------------------------------===// 28 29/// CreateTempAlloca - This creates a alloca and inserts it into the entry 30/// block. 31llvm::AllocaInst *CodeGenFunction::CreateTempAlloca(const llvm::Type *Ty, 32 const char *Name) { 33 return new llvm::AllocaInst(Ty, 0, Name, AllocaInsertPt); 34} 35 36/// EvaluateExprAsBool - Perform the usual unary conversions on the specified 37/// expression and compare the result against zero, returning an Int1Ty value. 38llvm::Value *CodeGenFunction::EvaluateExprAsBool(const Expr *E) { 39 QualType BoolTy = getContext().BoolTy; 40 if (!E->getType()->isComplexType()) 41 return EmitScalarConversion(EmitScalarExpr(E), E->getType(), BoolTy); 42 43 return EmitComplexToScalarConversion(EmitComplexExpr(E), E->getType(),BoolTy); 44} 45 46/// EmitAnyExpr - Emit code to compute the specified expression which can have 47/// any type. The result is returned as an RValue struct. If this is an 48/// aggregate expression, the aggloc/agglocvolatile arguments indicate where 49/// the result should be returned. 50RValue CodeGenFunction::EmitAnyExpr(const Expr *E, llvm::Value *AggLoc, 51 bool isAggLocVolatile) { 52 if (!hasAggregateLLVMType(E->getType())) 53 return RValue::get(EmitScalarExpr(E)); 54 else if (E->getType()->isComplexType()) 55 return RValue::getComplex(EmitComplexExpr(E)); 56 57 EmitAggExpr(E, AggLoc, isAggLocVolatile); 58 return RValue::getAggregate(AggLoc); 59} 60 61 62//===----------------------------------------------------------------------===// 63// LValue Expression Emission 64//===----------------------------------------------------------------------===// 65 66/// EmitLValue - Emit code to compute a designator that specifies the location 67/// of the expression. 68/// 69/// This can return one of two things: a simple address or a bitfield 70/// reference. In either case, the LLVM Value* in the LValue structure is 71/// guaranteed to be an LLVM pointer type. 72/// 73/// If this returns a bitfield reference, nothing about the pointee type of 74/// the LLVM value is known: For example, it may not be a pointer to an 75/// integer. 76/// 77/// If this returns a normal address, and if the lvalue's C type is fixed 78/// size, this method guarantees that the returned pointer type will point to 79/// an LLVM type of the same size of the lvalue's type. If the lvalue has a 80/// variable length type, this is not possible. 81/// 82LValue CodeGenFunction::EmitLValue(const Expr *E) { 83 switch (E->getStmtClass()) { 84 default: { 85 WarnUnsupported(E, "l-value expression"); 86 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType())); 87 return LValue::MakeAddr(llvm::UndefValue::get(Ty)); 88 } 89 90 case Expr::CallExprClass: return EmitCallExprLValue(cast<CallExpr>(E)); 91 case Expr::DeclRefExprClass: return EmitDeclRefLValue(cast<DeclRefExpr>(E)); 92 case Expr::ParenExprClass:return EmitLValue(cast<ParenExpr>(E)->getSubExpr()); 93 case Expr::PreDefinedExprClass: 94 return EmitPreDefinedLValue(cast<PreDefinedExpr>(E)); 95 case Expr::StringLiteralClass: 96 return EmitStringLiteralLValue(cast<StringLiteral>(E)); 97 98 case Expr::UnaryOperatorClass: 99 return EmitUnaryOpLValue(cast<UnaryOperator>(E)); 100 case Expr::ArraySubscriptExprClass: 101 return EmitArraySubscriptExpr(cast<ArraySubscriptExpr>(E)); 102 case Expr::OCUVectorElementExprClass: 103 return EmitOCUVectorElementExpr(cast<OCUVectorElementExpr>(E)); 104 case Expr::MemberExprClass: return EmitMemberExpr(cast<MemberExpr>(E)); 105 } 106} 107 108/// EmitLoadOfLValue - Given an expression that represents a value lvalue, 109/// this method emits the address of the lvalue, then loads the result as an 110/// rvalue, returning the rvalue. 111RValue CodeGenFunction::EmitLoadOfLValue(LValue LV, QualType ExprType) { 112 if (LV.isSimple()) { 113 llvm::Value *Ptr = LV.getAddress(); 114 const llvm::Type *EltTy = 115 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 116 117 // Simple scalar l-value. 118 if (EltTy->isFirstClassType()) { 119 llvm::Value *V = Builder.CreateLoad(Ptr, "tmp"); 120 121 // Bool can have different representation in memory than in registers. 122 if (ExprType->isBooleanType()) { 123 if (V->getType() != llvm::Type::Int1Ty) 124 V = Builder.CreateTrunc(V, llvm::Type::Int1Ty, "tobool"); 125 } 126 127 return RValue::get(V); 128 } 129 130 assert(ExprType->isFunctionType() && "Unknown scalar value"); 131 return RValue::get(Ptr); 132 } 133 134 if (LV.isVectorElt()) { 135 llvm::Value *Vec = Builder.CreateLoad(LV.getVectorAddr(), "tmp"); 136 return RValue::get(Builder.CreateExtractElement(Vec, LV.getVectorIdx(), 137 "vecext")); 138 } 139 140 // If this is a reference to a subset of the elements of a vector, either 141 // shuffle the input or extract/insert them as appropriate. 142 if (LV.isOCUVectorElt()) 143 return EmitLoadOfOCUElementLValue(LV, ExprType); 144 145 if (LV.isBitfield()) 146 return EmitLoadOfBitfieldLValue(LV, ExprType); 147 148 assert(0 && "Unknown LValue type!"); 149 //an invalid RValue, but the assert will 150 //ensure that this point is never reached 151 return RValue(); 152} 153 154RValue CodeGenFunction::EmitLoadOfBitfieldLValue(LValue LV, 155 QualType ExprType) { 156 llvm::Value *Ptr = LV.getBitfieldAddr(); 157 const llvm::Type *EltTy = 158 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 159 unsigned EltTySize = EltTy->getPrimitiveSizeInBits(); 160 unsigned short BitfieldSize = LV.getBitfieldSize(); 161 unsigned short EndBit = LV.getBitfieldStartBit() + BitfieldSize; 162 163 llvm::Value *V = Builder.CreateLoad(Ptr, "tmp"); 164 165 llvm::Value *ShAmt = llvm::ConstantInt::get(EltTy, EltTySize - EndBit); 166 V = Builder.CreateShl(V, ShAmt, "tmp"); 167 168 ShAmt = llvm::ConstantInt::get(EltTy, EltTySize - BitfieldSize); 169 V = LV.isBitfieldSigned() ? 170 Builder.CreateAShr(V, ShAmt, "tmp") : 171 Builder.CreateLShr(V, ShAmt, "tmp"); 172 return RValue::get(V); 173} 174 175// If this is a reference to a subset of the elements of a vector, either 176// shuffle the input or extract/insert them as appropriate. 177RValue CodeGenFunction::EmitLoadOfOCUElementLValue(LValue LV, 178 QualType ExprType) { 179 llvm::Value *Vec = Builder.CreateLoad(LV.getOCUVectorAddr(), "tmp"); 180 181 unsigned EncFields = LV.getOCUVectorElts(); 182 183 // If the result of the expression is a non-vector type, we must be 184 // extracting a single element. Just codegen as an extractelement. 185 const VectorType *ExprVT = ExprType->getAsVectorType(); 186 if (!ExprVT) { 187 unsigned InIdx = OCUVectorElementExpr::getAccessedFieldNo(0, EncFields); 188 llvm::Value *Elt = llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx); 189 return RValue::get(Builder.CreateExtractElement(Vec, Elt, "tmp")); 190 } 191 192 // If the source and destination have the same number of elements, use a 193 // vector shuffle instead of insert/extracts. 194 unsigned NumResultElts = ExprVT->getNumElements(); 195 unsigned NumSourceElts = 196 cast<llvm::VectorType>(Vec->getType())->getNumElements(); 197 198 if (NumResultElts == NumSourceElts) { 199 llvm::SmallVector<llvm::Constant*, 4> Mask; 200 for (unsigned i = 0; i != NumResultElts; ++i) { 201 unsigned InIdx = OCUVectorElementExpr::getAccessedFieldNo(i, EncFields); 202 Mask.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx)); 203 } 204 205 llvm::Value *MaskV = llvm::ConstantVector::get(&Mask[0], Mask.size()); 206 Vec = Builder.CreateShuffleVector(Vec, 207 llvm::UndefValue::get(Vec->getType()), 208 MaskV, "tmp"); 209 return RValue::get(Vec); 210 } 211 212 // Start out with an undef of the result type. 213 llvm::Value *Result = llvm::UndefValue::get(ConvertType(ExprType)); 214 215 // Extract/Insert each element of the result. 216 for (unsigned i = 0; i != NumResultElts; ++i) { 217 unsigned InIdx = OCUVectorElementExpr::getAccessedFieldNo(i, EncFields); 218 llvm::Value *Elt = llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx); 219 Elt = Builder.CreateExtractElement(Vec, Elt, "tmp"); 220 221 llvm::Value *OutIdx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i); 222 Result = Builder.CreateInsertElement(Result, Elt, OutIdx, "tmp"); 223 } 224 225 return RValue::get(Result); 226} 227 228 229 230/// EmitStoreThroughLValue - Store the specified rvalue into the specified 231/// lvalue, where both are guaranteed to the have the same type, and that type 232/// is 'Ty'. 233void CodeGenFunction::EmitStoreThroughLValue(RValue Src, LValue Dst, 234 QualType Ty) { 235 if (!Dst.isSimple()) { 236 if (Dst.isVectorElt()) { 237 // Read/modify/write the vector, inserting the new element. 238 // FIXME: Volatility. 239 llvm::Value *Vec = Builder.CreateLoad(Dst.getVectorAddr(), "tmp"); 240 Vec = Builder.CreateInsertElement(Vec, Src.getScalarVal(), 241 Dst.getVectorIdx(), "vecins"); 242 Builder.CreateStore(Vec, Dst.getVectorAddr()); 243 return; 244 } 245 246 // If this is an update of elements of a vector, insert them as appropriate. 247 if (Dst.isOCUVectorElt()) 248 return EmitStoreThroughOCUComponentLValue(Src, Dst, Ty); 249 250 if (Dst.isBitfield()) 251 return EmitStoreThroughBitfieldLValue(Src, Dst, Ty); 252 253 assert(0 && "Unknown LValue type"); 254 } 255 256 llvm::Value *DstAddr = Dst.getAddress(); 257 assert(Src.isScalar() && "Can't emit an agg store with this method"); 258 // FIXME: Handle volatility etc. 259 const llvm::Type *SrcTy = Src.getScalarVal()->getType(); 260 const llvm::PointerType *DstPtr = cast<llvm::PointerType>(DstAddr->getType()); 261 const llvm::Type *AddrTy = DstPtr->getElementType(); 262 unsigned AS = DstPtr->getAddressSpace(); 263 264 if (AddrTy != SrcTy) 265 DstAddr = Builder.CreateBitCast(DstAddr, 266 llvm::PointerType::get(SrcTy, AS), 267 "storetmp"); 268 Builder.CreateStore(Src.getScalarVal(), DstAddr); 269} 270 271void CodeGenFunction::EmitStoreThroughBitfieldLValue(RValue Src, LValue Dst, 272 QualType Ty) { 273 unsigned short StartBit = Dst.getBitfieldStartBit(); 274 unsigned short BitfieldSize = Dst.getBitfieldSize(); 275 llvm::Value *Ptr = Dst.getBitfieldAddr(); 276 const llvm::Type *EltTy = 277 cast<llvm::PointerType>(Ptr->getType())->getElementType(); 278 unsigned EltTySize = EltTy->getPrimitiveSizeInBits(); 279 280 llvm::Value *NewVal = Src.getScalarVal(); 281 llvm::Value *OldVal = Builder.CreateLoad(Ptr, "tmp"); 282 283 llvm::Value *ShAmt = llvm::ConstantInt::get(EltTy, StartBit); 284 NewVal = Builder.CreateShl(NewVal, ShAmt, "tmp"); 285 286 llvm::Constant *Mask = llvm::ConstantInt::get( 287 llvm::APInt::getBitsSet(EltTySize, StartBit, 288 StartBit + BitfieldSize)); 289 290 // Mask out any bits that shouldn't be set in the result. 291 NewVal = Builder.CreateAnd(NewVal, Mask, "tmp"); 292 293 // Next, mask out the bits this bit-field should include from the old value. 294 Mask = llvm::ConstantExpr::getNot(Mask); 295 OldVal = Builder.CreateAnd(OldVal, Mask, "tmp"); 296 297 // Finally, merge the two together and store it. 298 NewVal = Builder.CreateOr(OldVal, NewVal, "tmp"); 299 300 Builder.CreateStore(NewVal, Ptr); 301} 302 303void CodeGenFunction::EmitStoreThroughOCUComponentLValue(RValue Src, LValue Dst, 304 QualType Ty) { 305 // This access turns into a read/modify/write of the vector. Load the input 306 // value now. 307 llvm::Value *Vec = Builder.CreateLoad(Dst.getOCUVectorAddr(), "tmp"); 308 // FIXME: Volatility. 309 unsigned EncFields = Dst.getOCUVectorElts(); 310 311 llvm::Value *SrcVal = Src.getScalarVal(); 312 313 if (const VectorType *VTy = Ty->getAsVectorType()) { 314 unsigned NumSrcElts = VTy->getNumElements(); 315 316 // Extract/Insert each element. 317 for (unsigned i = 0; i != NumSrcElts; ++i) { 318 llvm::Value *Elt = llvm::ConstantInt::get(llvm::Type::Int32Ty, i); 319 Elt = Builder.CreateExtractElement(SrcVal, Elt, "tmp"); 320 321 unsigned Idx = OCUVectorElementExpr::getAccessedFieldNo(i, EncFields); 322 llvm::Value *OutIdx = llvm::ConstantInt::get(llvm::Type::Int32Ty, Idx); 323 Vec = Builder.CreateInsertElement(Vec, Elt, OutIdx, "tmp"); 324 } 325 } else { 326 // If the Src is a scalar (not a vector) it must be updating one element. 327 unsigned InIdx = OCUVectorElementExpr::getAccessedFieldNo(0, EncFields); 328 llvm::Value *Elt = llvm::ConstantInt::get(llvm::Type::Int32Ty, InIdx); 329 Vec = Builder.CreateInsertElement(Vec, SrcVal, Elt, "tmp"); 330 } 331 332 Builder.CreateStore(Vec, Dst.getOCUVectorAddr()); 333} 334 335 336LValue CodeGenFunction::EmitDeclRefLValue(const DeclRefExpr *E) { 337 const ValueDecl *D = E->getDecl(); 338 if (isa<BlockVarDecl>(D) || isa<ParmVarDecl>(D)) { 339 const VarDecl *VD = cast<VarDecl>(D); 340 if (VD->getStorageClass() == VarDecl::Extern) 341 return LValue::MakeAddr(CGM.GetAddrOfGlobalVar(VD, false)); 342 else { 343 llvm::Value *V = LocalDeclMap[D]; 344 assert(V && "BlockVarDecl not entered in LocalDeclMap?"); 345 return LValue::MakeAddr(V); 346 } 347 } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 348 return LValue::MakeAddr(CGM.GetAddrOfFunctionDecl(FD, false)); 349 } else if (const FileVarDecl *FVD = dyn_cast<FileVarDecl>(D)) { 350 return LValue::MakeAddr(CGM.GetAddrOfGlobalVar(FVD, false)); 351 } 352 assert(0 && "Unimp declref"); 353 //an invalid LValue, but the assert will 354 //ensure that this point is never reached. 355 return LValue(); 356} 357 358LValue CodeGenFunction::EmitUnaryOpLValue(const UnaryOperator *E) { 359 // __extension__ doesn't affect lvalue-ness. 360 if (E->getOpcode() == UnaryOperator::Extension) 361 return EmitLValue(E->getSubExpr()); 362 363 switch (E->getOpcode()) { 364 default: assert(0 && "Unknown unary operator lvalue!"); 365 case UnaryOperator::Deref: 366 return LValue::MakeAddr(EmitScalarExpr(E->getSubExpr())); 367 case UnaryOperator::Real: 368 case UnaryOperator::Imag: 369 LValue LV = EmitLValue(E->getSubExpr()); 370 371 llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 372 llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 373 E->getOpcode() == UnaryOperator::Imag); 374 llvm::Value *Ops[] = {Zero, Idx}; 375 return LValue::MakeAddr(Builder.CreateGEP(LV.getAddress(), Ops, Ops+2, 376 "idx")); 377 } 378} 379 380LValue CodeGenFunction::EmitStringLiteralLValue(const StringLiteral *E) { 381 assert(!E->isWide() && "FIXME: Wide strings not supported yet!"); 382 const char *StrData = E->getStrData(); 383 unsigned Len = E->getByteLength(); 384 std::string StringLiteral(StrData, StrData+Len); 385 return LValue::MakeAddr(CGM.GetAddrOfConstantString(StringLiteral)); 386} 387 388LValue CodeGenFunction::EmitPreDefinedLValue(const PreDefinedExpr *E) { 389 std::string FunctionName(CurFuncDecl->getName()); 390 std::string GlobalVarName; 391 392 switch (E->getIdentType()) { 393 default: 394 assert(0 && "unknown pre-defined ident type"); 395 case PreDefinedExpr::Func: 396 GlobalVarName = "__func__."; 397 break; 398 case PreDefinedExpr::Function: 399 GlobalVarName = "__FUNCTION__."; 400 break; 401 case PreDefinedExpr::PrettyFunction: 402 // FIXME:: Demangle C++ method names 403 GlobalVarName = "__PRETTY_FUNCTION__."; 404 break; 405 } 406 407 GlobalVarName += CurFuncDecl->getName(); 408 409 // FIXME: Can cache/reuse these within the module. 410 llvm::Constant *C=llvm::ConstantArray::get(FunctionName); 411 412 // Create a global variable for this. 413 C = new llvm::GlobalVariable(C->getType(), true, 414 llvm::GlobalValue::InternalLinkage, 415 C, GlobalVarName, CurFn->getParent()); 416 return LValue::MakeAddr(C); 417} 418 419LValue CodeGenFunction::EmitArraySubscriptExpr(const ArraySubscriptExpr *E) { 420 // The index must always be an integer, which is not an aggregate. Emit it. 421 llvm::Value *Idx = EmitScalarExpr(E->getIdx()); 422 423 // If the base is a vector type, then we are forming a vector element lvalue 424 // with this subscript. 425 if (E->getLHS()->getType()->isVectorType()) { 426 // Emit the vector as an lvalue to get its address. 427 LValue LHS = EmitLValue(E->getLHS()); 428 assert(LHS.isSimple() && "Can only subscript lvalue vectors here!"); 429 // FIXME: This should properly sign/zero/extend or truncate Idx to i32. 430 return LValue::MakeVectorElt(LHS.getAddress(), Idx); 431 } 432 433 // The base must be a pointer, which is not an aggregate. Emit it. 434 llvm::Value *Base = EmitScalarExpr(E->getBase()); 435 436 // Extend or truncate the index type to 32 or 64-bits. 437 QualType IdxTy = E->getIdx()->getType(); 438 bool IdxSigned = IdxTy->isSignedIntegerType(); 439 unsigned IdxBitwidth = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 440 if (IdxBitwidth != LLVMPointerWidth) 441 Idx = Builder.CreateIntCast(Idx, llvm::IntegerType::get(LLVMPointerWidth), 442 IdxSigned, "idxprom"); 443 444 // We know that the pointer points to a type of the correct size, unless the 445 // size is a VLA. 446 if (!E->getType()->isConstantSizeType()) 447 assert(0 && "VLA idx not implemented"); 448 return LValue::MakeAddr(Builder.CreateGEP(Base, Idx, "arrayidx")); 449} 450 451LValue CodeGenFunction:: 452EmitOCUVectorElementExpr(const OCUVectorElementExpr *E) { 453 // Emit the base vector as an l-value. 454 LValue Base = EmitLValue(E->getBase()); 455 assert(Base.isSimple() && "Can only subscript lvalue vectors here!"); 456 457 return LValue::MakeOCUVectorElt(Base.getAddress(), 458 E->getEncodedElementAccess()); 459} 460 461LValue CodeGenFunction::EmitMemberExpr(const MemberExpr *E) { 462 bool isUnion = false; 463 Expr *BaseExpr = E->getBase(); 464 llvm::Value *BaseValue = NULL; 465 466 // If this is s.x, emit s as an lvalue. If it is s->x, emit s as a scalar. 467 if (E->isArrow()) { 468 BaseValue = EmitScalarExpr(BaseExpr); 469 const PointerType *PTy = 470 cast<PointerType>(BaseExpr->getType().getCanonicalType()); 471 if (PTy->getPointeeType()->isUnionType()) 472 isUnion = true; 473 } 474 else { 475 LValue BaseLV = EmitLValue(BaseExpr); 476 // FIXME: this isn't right for bitfields. 477 BaseValue = BaseLV.getAddress(); 478 if (BaseExpr->getType()->isUnionType()) 479 isUnion = true; 480 } 481 482 FieldDecl *Field = E->getMemberDecl(); 483 return EmitLValueForField(BaseValue, Field, isUnion); 484} 485 486LValue CodeGenFunction::EmitLValueForField(llvm::Value* BaseValue, 487 FieldDecl* Field, 488 bool isUnion) 489{ 490 llvm::Value *V; 491 unsigned idx = CGM.getTypes().getLLVMFieldNo(Field); 492 493 if (Field->isBitField()) { 494 const llvm::Type * FieldTy = ConvertType(Field->getType()); 495 const llvm::PointerType * BaseTy = 496 cast<llvm::PointerType>(BaseValue->getType()); 497 unsigned AS = BaseTy->getAddressSpace(); 498 BaseValue = Builder.CreateBitCast(BaseValue, 499 llvm::PointerType::get(FieldTy, AS), 500 "tmp"); 501 V = Builder.CreateGEP(BaseValue, 502 llvm::ConstantInt::get(llvm::Type::Int32Ty, idx), 503 "tmp"); 504 } else { 505 llvm::Value *Idxs[2] = { llvm::Constant::getNullValue(llvm::Type::Int32Ty), 506 llvm::ConstantInt::get(llvm::Type::Int32Ty, idx) }; 507 V = Builder.CreateGEP(BaseValue,Idxs, Idxs + 2, "tmp"); 508 } 509 // Match union field type. 510 if (isUnion) { 511 const llvm::Type * FieldTy = ConvertType(Field->getType()); 512 const llvm::PointerType * BaseTy = 513 cast<llvm::PointerType>(BaseValue->getType()); 514 if (FieldTy != BaseTy->getElementType()) { 515 unsigned AS = BaseTy->getAddressSpace(); 516 V = Builder.CreateBitCast(V, 517 llvm::PointerType::get(FieldTy, AS), 518 "tmp"); 519 } 520 } 521 522 if (Field->isBitField()) { 523 CodeGenTypes::BitFieldInfo bitFieldInfo = 524 CGM.getTypes().getBitFieldInfo(Field); 525 return LValue::MakeBitfield(V, bitFieldInfo.Begin, bitFieldInfo.Size, 526 Field->getType()->isSignedIntegerType()); 527 } else 528 return LValue::MakeAddr(V); 529} 530 531//===--------------------------------------------------------------------===// 532// Expression Emission 533//===--------------------------------------------------------------------===// 534 535 536RValue CodeGenFunction::EmitCallExpr(const CallExpr *E) { 537 if (const ImplicitCastExpr *IcExpr = 538 dyn_cast<const ImplicitCastExpr>(E->getCallee())) 539 if (const DeclRefExpr *DRExpr = 540 dyn_cast<const DeclRefExpr>(IcExpr->getSubExpr())) 541 if (const FunctionDecl *FDecl = 542 dyn_cast<const FunctionDecl>(DRExpr->getDecl())) 543 if (unsigned builtinID = FDecl->getIdentifier()->getBuiltinID()) 544 return EmitBuiltinExpr(builtinID, E); 545 546 llvm::Value *Callee = EmitScalarExpr(E->getCallee()); 547 return EmitCallExpr(Callee, E->getCallee()->getType(), 548 E->arg_begin(), E->getNumArgs()); 549} 550 551RValue CodeGenFunction::EmitCallExpr(Expr *FnExpr, Expr *const *Args, 552 unsigned NumArgs) { 553 llvm::Value *Callee = EmitScalarExpr(FnExpr); 554 return EmitCallExpr(Callee, FnExpr->getType(), Args, NumArgs); 555} 556 557LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) { 558 // Can only get l-value for call expression returning aggregate type 559 RValue RV = EmitCallExpr(E); 560 return LValue::MakeAddr(RV.getAggregateAddr()); 561} 562 563RValue CodeGenFunction::EmitCallExpr(llvm::Value *Callee, QualType FnType, 564 Expr *const *ArgExprs, unsigned NumArgs) { 565 // The callee type will always be a pointer to function type, get the function 566 // type. 567 FnType = cast<PointerType>(FnType.getCanonicalType())->getPointeeType(); 568 QualType ResultType = cast<FunctionType>(FnType)->getResultType(); 569 570 llvm::SmallVector<llvm::Value*, 16> Args; 571 572 // Handle struct-return functions by passing a pointer to the location that 573 // we would like to return into. 574 if (hasAggregateLLVMType(ResultType)) { 575 // Create a temporary alloca to hold the result of the call. :( 576 Args.push_back(CreateTempAlloca(ConvertType(ResultType))); 577 // FIXME: set the stret attribute on the argument. 578 } 579 580 for (unsigned i = 0, e = NumArgs; i != e; ++i) { 581 QualType ArgTy = ArgExprs[i]->getType(); 582 583 if (!hasAggregateLLVMType(ArgTy)) { 584 // Scalar argument is passed by-value. 585 Args.push_back(EmitScalarExpr(ArgExprs[i])); 586 } else if (ArgTy->isComplexType()) { 587 // Make a temporary alloca to pass the argument. 588 llvm::Value *DestMem = CreateTempAlloca(ConvertType(ArgTy)); 589 EmitComplexExprIntoAddr(ArgExprs[i], DestMem, false); 590 Args.push_back(DestMem); 591 } else { 592 llvm::Value *DestMem = CreateTempAlloca(ConvertType(ArgTy)); 593 EmitAggExpr(ArgExprs[i], DestMem, false); 594 Args.push_back(DestMem); 595 } 596 } 597 598 llvm::CallInst *CI = Builder.CreateCall(Callee,&Args[0],&Args[0]+Args.size()); 599 if (const llvm::Function *F = dyn_cast<llvm::Function>(Callee)) 600 CI->setCallingConv(F->getCallingConv()); 601 if (CI->getType() != llvm::Type::VoidTy) 602 CI->setName("call"); 603 else if (ResultType->isComplexType()) 604 return RValue::getComplex(LoadComplexFromAddr(Args[0], false)); 605 else if (hasAggregateLLVMType(ResultType)) 606 // Struct return. 607 return RValue::getAggregate(Args[0]); 608 else { 609 // void return. 610 assert(ResultType->isVoidType() && "Should only have a void expr here"); 611 CI = 0; 612 } 613 614 return RValue::get(CI); 615} 616