CGExprScalar.cpp revision 531a550531c144a58438f187816abbf1879e1c4e
1//===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===// 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 with scalar LLVM types as LLVM code. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CodeGenFunction.h" 15#include "CodeGenModule.h" 16#include "clang/AST/ASTContext.h" 17#include "clang/AST/DeclObjC.h" 18#include "clang/AST/StmtVisitor.h" 19#include "clang/Basic/TargetInfo.h" 20#include "llvm/Constants.h" 21#include "llvm/Function.h" 22#include "llvm/GlobalVariable.h" 23#include "llvm/Intrinsics.h" 24#include "llvm/Support/Compiler.h" 25#include "llvm/Support/CFG.h" 26#include <cstdarg> 27 28using namespace clang; 29using namespace CodeGen; 30using llvm::Value; 31 32//===----------------------------------------------------------------------===// 33// Scalar Expression Emitter 34//===----------------------------------------------------------------------===// 35 36struct BinOpInfo { 37 Value *LHS; 38 Value *RHS; 39 QualType Ty; // Computation Type. 40 const BinaryOperator *E; 41}; 42 43namespace { 44class VISIBILITY_HIDDEN ScalarExprEmitter 45 : public StmtVisitor<ScalarExprEmitter, Value*> { 46 CodeGenFunction &CGF; 47 CGBuilderTy &Builder; 48 49public: 50 51 ScalarExprEmitter(CodeGenFunction &cgf) : CGF(cgf), 52 Builder(CGF.Builder) { 53 } 54 55 //===--------------------------------------------------------------------===// 56 // Utilities 57 //===--------------------------------------------------------------------===// 58 59 const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); } 60 LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); } 61 62 Value *EmitLoadOfLValue(LValue LV, QualType T) { 63 return CGF.EmitLoadOfLValue(LV, T).getScalarVal(); 64 } 65 66 /// EmitLoadOfLValue - Given an expression with complex type that represents a 67 /// value l-value, this method emits the address of the l-value, then loads 68 /// and returns the result. 69 Value *EmitLoadOfLValue(const Expr *E) { 70 // FIXME: Volatile 71 return EmitLoadOfLValue(EmitLValue(E), E->getType()); 72 } 73 74 /// EmitConversionToBool - Convert the specified expression value to a 75 /// boolean (i1) truth value. This is equivalent to "Val != 0". 76 Value *EmitConversionToBool(Value *Src, QualType DstTy); 77 78 /// EmitScalarConversion - Emit a conversion from the specified type to the 79 /// specified destination type, both of which are LLVM scalar types. 80 Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy); 81 82 /// EmitComplexToScalarConversion - Emit a conversion from the specified 83 /// complex type to the specified destination type, where the destination 84 /// type is an LLVM scalar type. 85 Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 86 QualType SrcTy, QualType DstTy); 87 88 //===--------------------------------------------------------------------===// 89 // Visitor Methods 90 //===--------------------------------------------------------------------===// 91 92 Value *VisitStmt(Stmt *S) { 93 S->dump(CGF.getContext().getSourceManager()); 94 assert(0 && "Stmt can't have complex result type!"); 95 return 0; 96 } 97 Value *VisitExpr(Expr *S); 98 Value *VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr()); } 99 100 // Leaves. 101 Value *VisitIntegerLiteral(const IntegerLiteral *E) { 102 return llvm::ConstantInt::get(E->getValue()); 103 } 104 Value *VisitFloatingLiteral(const FloatingLiteral *E) { 105 return llvm::ConstantFP::get(E->getValue()); 106 } 107 Value *VisitCharacterLiteral(const CharacterLiteral *E) { 108 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 109 } 110 Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 111 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 112 } 113 Value *VisitCXXZeroInitValueExpr(const CXXZeroInitValueExpr *E) { 114 return llvm::Constant::getNullValue(ConvertType(E->getType())); 115 } 116 Value *VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) { 117 return llvm::ConstantInt::get(ConvertType(E->getType()), 118 CGF.getContext().typesAreCompatible( 119 E->getArgType1(), E->getArgType2())); 120 } 121 Value *VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E); 122 Value *VisitAddrLabelExpr(const AddrLabelExpr *E) { 123 llvm::Value *V = 124 llvm::ConstantInt::get(llvm::Type::Int32Ty, 125 CGF.GetIDForAddrOfLabel(E->getLabel())); 126 127 return Builder.CreateIntToPtr(V, ConvertType(E->getType())); 128 } 129 130 // l-values. 131 Value *VisitDeclRefExpr(DeclRefExpr *E) { 132 if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(E->getDecl())) 133 return llvm::ConstantInt::get(EC->getInitVal()); 134 return EmitLoadOfLValue(E); 135 } 136 Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 137 return CGF.EmitObjCSelectorExpr(E); 138 } 139 Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 140 return CGF.EmitObjCProtocolExpr(E); 141 } 142 Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 143 return EmitLoadOfLValue(E); 144 } 145 Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 146 return EmitLoadOfLValue(E); 147 } 148 Value *VisitObjCMessageExpr(ObjCMessageExpr *E) { 149 return CGF.EmitObjCMessageExpr(E).getScalarVal(); 150 } 151 152 Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 153 Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E); 154 Value *VisitMemberExpr(Expr *E) { return EmitLoadOfLValue(E); } 155 Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); } 156 Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 157 return EmitLoadOfLValue(E); 158 } 159 Value *VisitStringLiteral(Expr *E) { return EmitLValue(E).getAddress(); } 160 Value *VisitPredefinedExpr(Expr *E) { return EmitLValue(E).getAddress(); } 161 162 Value *VisitInitListExpr(InitListExpr *E) { 163 unsigned NumInitElements = E->getNumInits(); 164 165 const llvm::VectorType *VType = 166 dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 167 168 // We have a scalar in braces. Just use the first element. 169 if (!VType) 170 return Visit(E->getInit(0)); 171 172 if (E->hadDesignators()) { 173 CGF.ErrorUnsupported(E, "initializer list with designators"); 174 return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 175 } 176 177 unsigned NumVectorElements = VType->getNumElements(); 178 const llvm::Type *ElementType = VType->getElementType(); 179 180 // Emit individual vector element stores. 181 llvm::Value *V = llvm::UndefValue::get(VType); 182 183 // Emit initializers 184 unsigned i; 185 for (i = 0; i < NumInitElements; ++i) { 186 Value *NewV = Visit(E->getInit(i)); 187 Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i); 188 V = Builder.CreateInsertElement(V, NewV, Idx); 189 } 190 191 // Emit remaining default initializers 192 for (/* Do not initialize i*/; i < NumVectorElements; ++i) { 193 Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i); 194 llvm::Value *NewV = llvm::Constant::getNullValue(ElementType); 195 V = Builder.CreateInsertElement(V, NewV, Idx); 196 } 197 198 return V; 199 } 200 201 Value *VisitImplicitCastExpr(const ImplicitCastExpr *E); 202 Value *VisitCastExpr(const CastExpr *E) { 203 return EmitCastExpr(E->getSubExpr(), E->getType()); 204 } 205 Value *EmitCastExpr(const Expr *E, QualType T); 206 207 Value *VisitCallExpr(const CallExpr *E) { 208 return CGF.EmitCallExpr(E).getScalarVal(); 209 } 210 211 Value *VisitStmtExpr(const StmtExpr *E); 212 213 // Unary Operators. 214 Value *VisitPrePostIncDec(const UnaryOperator *E, bool isInc, bool isPre); 215 Value *VisitUnaryPostDec(const UnaryOperator *E) { 216 return VisitPrePostIncDec(E, false, false); 217 } 218 Value *VisitUnaryPostInc(const UnaryOperator *E) { 219 return VisitPrePostIncDec(E, true, false); 220 } 221 Value *VisitUnaryPreDec(const UnaryOperator *E) { 222 return VisitPrePostIncDec(E, false, true); 223 } 224 Value *VisitUnaryPreInc(const UnaryOperator *E) { 225 return VisitPrePostIncDec(E, true, true); 226 } 227 Value *VisitUnaryAddrOf(const UnaryOperator *E) { 228 return EmitLValue(E->getSubExpr()).getAddress(); 229 } 230 Value *VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 231 Value *VisitUnaryPlus(const UnaryOperator *E) { 232 return Visit(E->getSubExpr()); 233 } 234 Value *VisitUnaryMinus (const UnaryOperator *E); 235 Value *VisitUnaryNot (const UnaryOperator *E); 236 Value *VisitUnaryLNot (const UnaryOperator *E); 237 Value *VisitUnaryReal (const UnaryOperator *E); 238 Value *VisitUnaryImag (const UnaryOperator *E); 239 Value *VisitUnaryExtension(const UnaryOperator *E) { 240 return Visit(E->getSubExpr()); 241 } 242 Value *VisitUnaryOffsetOf(const UnaryOperator *E); 243 Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 244 return Visit(DAE->getExpr()); 245 } 246 247 // Binary Operators. 248 Value *EmitMul(const BinOpInfo &Ops) { 249 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 250 } 251 Value *EmitDiv(const BinOpInfo &Ops); 252 Value *EmitRem(const BinOpInfo &Ops); 253 Value *EmitAdd(const BinOpInfo &Ops); 254 Value *EmitSub(const BinOpInfo &Ops); 255 Value *EmitShl(const BinOpInfo &Ops); 256 Value *EmitShr(const BinOpInfo &Ops); 257 Value *EmitAnd(const BinOpInfo &Ops) { 258 return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 259 } 260 Value *EmitXor(const BinOpInfo &Ops) { 261 return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 262 } 263 Value *EmitOr (const BinOpInfo &Ops) { 264 return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 265 } 266 267 BinOpInfo EmitBinOps(const BinaryOperator *E); 268 Value *EmitCompoundAssign(const CompoundAssignOperator *E, 269 Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 270 271 // Binary operators and binary compound assignment operators. 272#define HANDLEBINOP(OP) \ 273 Value *VisitBin ## OP(const BinaryOperator *E) { \ 274 return Emit ## OP(EmitBinOps(E)); \ 275 } \ 276 Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 277 return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 278 } 279 HANDLEBINOP(Mul); 280 HANDLEBINOP(Div); 281 HANDLEBINOP(Rem); 282 HANDLEBINOP(Add); 283 HANDLEBINOP(Sub); 284 HANDLEBINOP(Shl); 285 HANDLEBINOP(Shr); 286 HANDLEBINOP(And); 287 HANDLEBINOP(Xor); 288 HANDLEBINOP(Or); 289#undef HANDLEBINOP 290 291 // Comparisons. 292 Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 293 unsigned SICmpOpc, unsigned FCmpOpc); 294#define VISITCOMP(CODE, UI, SI, FP) \ 295 Value *VisitBin##CODE(const BinaryOperator *E) { \ 296 return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 297 llvm::FCmpInst::FP); } 298 VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT); 299 VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT); 300 VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE); 301 VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE); 302 VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ); 303 VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE); 304#undef VISITCOMP 305 306 Value *VisitBinAssign (const BinaryOperator *E); 307 308 Value *VisitBinLAnd (const BinaryOperator *E); 309 Value *VisitBinLOr (const BinaryOperator *E); 310 Value *VisitBinComma (const BinaryOperator *E); 311 312 // Other Operators. 313 Value *VisitConditionalOperator(const ConditionalOperator *CO); 314 Value *VisitChooseExpr(ChooseExpr *CE); 315 Value *VisitOverloadExpr(OverloadExpr *OE); 316 Value *VisitVAArgExpr(VAArgExpr *VE); 317 Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 318 return CGF.EmitObjCStringLiteral(E); 319 } 320 Value *VisitObjCEncodeExpr(const ObjCEncodeExpr *E); 321}; 322} // end anonymous namespace. 323 324//===----------------------------------------------------------------------===// 325// Utilities 326//===----------------------------------------------------------------------===// 327 328/// EmitConversionToBool - Convert the specified expression value to a 329/// boolean (i1) truth value. This is equivalent to "Val != 0". 330Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 331 assert(SrcType->isCanonical() && "EmitScalarConversion strips typedefs"); 332 333 if (SrcType->isRealFloatingType()) { 334 // Compare against 0.0 for fp scalars. 335 llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 336 return Builder.CreateFCmpUNE(Src, Zero, "tobool"); 337 } 338 339 assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 340 "Unknown scalar type to convert"); 341 342 // Because of the type rules of C, we often end up computing a logical value, 343 // then zero extending it to int, then wanting it as a logical value again. 344 // Optimize this common case. 345 if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(Src)) { 346 if (ZI->getOperand(0)->getType() == llvm::Type::Int1Ty) { 347 Value *Result = ZI->getOperand(0); 348 // If there aren't any more uses, zap the instruction to save space. 349 // Note that there can be more uses, for example if this 350 // is the result of an assignment. 351 if (ZI->use_empty()) 352 ZI->eraseFromParent(); 353 return Result; 354 } 355 } 356 357 // Compare against an integer or pointer null. 358 llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 359 return Builder.CreateICmpNE(Src, Zero, "tobool"); 360} 361 362/// EmitScalarConversion - Emit a conversion from the specified type to the 363/// specified destination type, both of which are LLVM scalar types. 364Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 365 QualType DstType) { 366 SrcType = CGF.getContext().getCanonicalType(SrcType); 367 DstType = CGF.getContext().getCanonicalType(DstType); 368 if (SrcType == DstType) return Src; 369 370 if (DstType->isVoidType()) return 0; 371 372 // Handle conversions to bool first, they are special: comparisons against 0. 373 if (DstType->isBooleanType()) 374 return EmitConversionToBool(Src, SrcType); 375 376 const llvm::Type *DstTy = ConvertType(DstType); 377 378 // Ignore conversions like int -> uint. 379 if (Src->getType() == DstTy) 380 return Src; 381 382 // Handle pointer conversions next: pointers can only be converted 383 // to/from other pointers and integers. Check for pointer types in 384 // terms of LLVM, as some native types (like Obj-C id) may map to a 385 // pointer type. 386 if (isa<llvm::PointerType>(DstTy)) { 387 // The source value may be an integer, or a pointer. 388 if (isa<llvm::PointerType>(Src->getType())) 389 return Builder.CreateBitCast(Src, DstTy, "conv"); 390 assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 391 return Builder.CreateIntToPtr(Src, DstTy, "conv"); 392 } 393 394 if (isa<llvm::PointerType>(Src->getType())) { 395 // Must be an ptr to int cast. 396 assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 397 return Builder.CreatePtrToInt(Src, DstTy, "conv"); 398 } 399 400 // A scalar can be splatted to an extended vector of the same element type 401 if (DstType->isExtVectorType() && !isa<VectorType>(SrcType) && 402 cast<llvm::VectorType>(DstTy)->getElementType() == Src->getType()) 403 return CGF.EmitVector(&Src, DstType->getAsVectorType()->getNumElements(), 404 true); 405 406 // Allow bitcast from vector to integer/fp of the same size. 407 if (isa<llvm::VectorType>(Src->getType()) || 408 isa<llvm::VectorType>(DstTy)) 409 return Builder.CreateBitCast(Src, DstTy, "conv"); 410 411 // Finally, we have the arithmetic types: real int/float. 412 if (isa<llvm::IntegerType>(Src->getType())) { 413 bool InputSigned = SrcType->isSignedIntegerType(); 414 if (isa<llvm::IntegerType>(DstTy)) 415 return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 416 else if (InputSigned) 417 return Builder.CreateSIToFP(Src, DstTy, "conv"); 418 else 419 return Builder.CreateUIToFP(Src, DstTy, "conv"); 420 } 421 422 assert(Src->getType()->isFloatingPoint() && "Unknown real conversion"); 423 if (isa<llvm::IntegerType>(DstTy)) { 424 if (DstType->isSignedIntegerType()) 425 return Builder.CreateFPToSI(Src, DstTy, "conv"); 426 else 427 return Builder.CreateFPToUI(Src, DstTy, "conv"); 428 } 429 430 assert(DstTy->isFloatingPoint() && "Unknown real conversion"); 431 if (DstTy->getTypeID() < Src->getType()->getTypeID()) 432 return Builder.CreateFPTrunc(Src, DstTy, "conv"); 433 else 434 return Builder.CreateFPExt(Src, DstTy, "conv"); 435} 436 437/// EmitComplexToScalarConversion - Emit a conversion from the specified 438/// complex type to the specified destination type, where the destination 439/// type is an LLVM scalar type. 440Value *ScalarExprEmitter:: 441EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 442 QualType SrcTy, QualType DstTy) { 443 // Get the source element type. 444 SrcTy = SrcTy->getAsComplexType()->getElementType(); 445 446 // Handle conversions to bool first, they are special: comparisons against 0. 447 if (DstTy->isBooleanType()) { 448 // Complex != 0 -> (Real != 0) | (Imag != 0) 449 Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 450 Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 451 return Builder.CreateOr(Src.first, Src.second, "tobool"); 452 } 453 454 // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 455 // the imaginary part of the complex value is discarded and the value of the 456 // real part is converted according to the conversion rules for the 457 // corresponding real type. 458 return EmitScalarConversion(Src.first, SrcTy, DstTy); 459} 460 461 462//===----------------------------------------------------------------------===// 463// Visitor Methods 464//===----------------------------------------------------------------------===// 465 466Value *ScalarExprEmitter::VisitExpr(Expr *E) { 467 CGF.ErrorUnsupported(E, "scalar expression"); 468 if (E->getType()->isVoidType()) 469 return 0; 470 return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 471} 472 473Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 474 llvm::SmallVector<llvm::Constant*, 32> indices; 475 for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 476 indices.push_back(cast<llvm::Constant>(CGF.EmitScalarExpr(E->getExpr(i)))); 477 } 478 Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 479 Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 480 Value* SV = llvm::ConstantVector::get(indices.begin(), indices.size()); 481 return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 482} 483 484Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 485 // Emit subscript expressions in rvalue context's. For most cases, this just 486 // loads the lvalue formed by the subscript expr. However, we have to be 487 // careful, because the base of a vector subscript is occasionally an rvalue, 488 // so we can't get it as an lvalue. 489 if (!E->getBase()->getType()->isVectorType()) 490 return EmitLoadOfLValue(E); 491 492 // Handle the vector case. The base must be a vector, the index must be an 493 // integer value. 494 Value *Base = Visit(E->getBase()); 495 Value *Idx = Visit(E->getIdx()); 496 497 // FIXME: Convert Idx to i32 type. 498 return Builder.CreateExtractElement(Base, Idx, "vecext"); 499} 500 501/// VisitImplicitCastExpr - Implicit casts are the same as normal casts, but 502/// also handle things like function to pointer-to-function decay, and array to 503/// pointer decay. 504Value *ScalarExprEmitter::VisitImplicitCastExpr(const ImplicitCastExpr *E) { 505 const Expr *Op = E->getSubExpr(); 506 507 // If this is due to array->pointer conversion, emit the array expression as 508 // an l-value. 509 if (Op->getType()->isArrayType()) { 510 // FIXME: For now we assume that all source arrays map to LLVM arrays. This 511 // will not true when we add support for VLAs. 512 Value *V = EmitLValue(Op).getAddress(); // Bitfields can't be arrays. 513 514 if (!(isa<llvm::PointerType>(V->getType()) && 515 isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 516 ->getElementType()))) { 517 CGF.ErrorUnsupported(E, "variable-length array cast", true); 518 if (E->getType()->isVoidType()) 519 return 0; 520 return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 521 } 522 V = Builder.CreateStructGEP(V, 0, "arraydecay"); 523 524 // The resultant pointer type can be implicitly casted to other pointer 525 // types as well (e.g. void*) and can be implicitly converted to integer. 526 const llvm::Type *DestTy = ConvertType(E->getType()); 527 if (V->getType() != DestTy) { 528 if (isa<llvm::PointerType>(DestTy)) 529 V = Builder.CreateBitCast(V, DestTy, "ptrconv"); 530 else { 531 assert(isa<llvm::IntegerType>(DestTy) && "Unknown array decay"); 532 V = Builder.CreatePtrToInt(V, DestTy, "ptrconv"); 533 } 534 } 535 return V; 536 537 } else if (E->getType()->isReferenceType()) { 538 return EmitLValue(Op).getAddress(); 539 } 540 541 return EmitCastExpr(Op, E->getType()); 542} 543 544 545// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 546// have to handle a more broad range of conversions than explicit casts, as they 547// handle things like function to ptr-to-function decay etc. 548Value *ScalarExprEmitter::EmitCastExpr(const Expr *E, QualType DestTy) { 549 // Handle cases where the source is an non-complex type. 550 551 if (!CGF.hasAggregateLLVMType(E->getType())) { 552 Value *Src = Visit(const_cast<Expr*>(E)); 553 554 // Use EmitScalarConversion to perform the conversion. 555 return EmitScalarConversion(Src, E->getType(), DestTy); 556 } 557 558 if (E->getType()->isAnyComplexType()) { 559 // Handle cases where the source is a complex type. 560 return EmitComplexToScalarConversion(CGF.EmitComplexExpr(E), E->getType(), 561 DestTy); 562 } 563 564 // Okay, this is a cast from an aggregate. It must be a cast to void. Just 565 // evaluate the result and return. 566 CGF.EmitAggExpr(E, 0, false); 567 return 0; 568} 569 570Value *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 571 return CGF.EmitCompoundStmt(*E->getSubStmt(), 572 !E->getType()->isVoidType()).getScalarVal(); 573} 574 575 576//===----------------------------------------------------------------------===// 577// Unary Operators 578//===----------------------------------------------------------------------===// 579 580Value *ScalarExprEmitter::VisitPrePostIncDec(const UnaryOperator *E, 581 bool isInc, bool isPre) { 582 LValue LV = EmitLValue(E->getSubExpr()); 583 // FIXME: Handle volatile! 584 Value *InVal = CGF.EmitLoadOfLValue(LV, // false 585 E->getSubExpr()->getType()).getScalarVal(); 586 587 int AmountVal = isInc ? 1 : -1; 588 589 Value *NextVal; 590 if (isa<llvm::PointerType>(InVal->getType())) { 591 // FIXME: This isn't right for VLAs. 592 NextVal = llvm::ConstantInt::get(llvm::Type::Int32Ty, AmountVal); 593 NextVal = Builder.CreateGEP(InVal, NextVal, "ptrincdec"); 594 } else { 595 // Add the inc/dec to the real part. 596 if (isa<llvm::IntegerType>(InVal->getType())) 597 NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal); 598 else if (InVal->getType() == llvm::Type::FloatTy) 599 NextVal = 600 llvm::ConstantFP::get(llvm::APFloat(static_cast<float>(AmountVal))); 601 else if (InVal->getType() == llvm::Type::DoubleTy) 602 NextVal = 603 llvm::ConstantFP::get(llvm::APFloat(static_cast<double>(AmountVal))); 604 else { 605 llvm::APFloat F(static_cast<float>(AmountVal)); 606 bool ignored; 607 F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 608 &ignored); 609 NextVal = llvm::ConstantFP::get(F); 610 } 611 NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 612 } 613 614 // Store the updated result through the lvalue. 615 CGF.EmitStoreThroughLValue(RValue::get(NextVal), LV, 616 E->getSubExpr()->getType()); 617 618 // If this is a postinc, return the value read from memory, otherwise use the 619 // updated value. 620 return isPre ? NextVal : InVal; 621} 622 623 624Value *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 625 Value *Op = Visit(E->getSubExpr()); 626 return Builder.CreateNeg(Op, "neg"); 627} 628 629Value *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 630 Value *Op = Visit(E->getSubExpr()); 631 return Builder.CreateNot(Op, "neg"); 632} 633 634Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 635 // Compare operand to zero. 636 Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 637 638 // Invert value. 639 // TODO: Could dynamically modify easy computations here. For example, if 640 // the operand is an icmp ne, turn into icmp eq. 641 BoolVal = Builder.CreateNot(BoolVal, "lnot"); 642 643 // ZExt result to int. 644 return Builder.CreateZExt(BoolVal, CGF.LLVMIntTy, "lnot.ext"); 645} 646 647/// VisitSizeOfAlignOfExpr - Return the size or alignment of the type of 648/// argument of the sizeof expression as an integer. 649Value * 650ScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) { 651 QualType RetType = E->getType(); 652 assert(RetType->isIntegerType() && "Result type must be an integer!"); 653 uint32_t ResultWidth = 654 static_cast<uint32_t>(CGF.getContext().getTypeSize(RetType)); 655 656 QualType TypeToSize = E->getTypeOfArgument(); 657 // sizeof(void) and __alignof__(void) = 1 as a gcc extension. Also 658 // for function types. 659 // FIXME: what is alignof a function type in gcc? 660 if (TypeToSize->isVoidType() || TypeToSize->isFunctionType()) 661 return llvm::ConstantInt::get(llvm::APInt(ResultWidth, 1)); 662 663 /// FIXME: This doesn't handle VLAs yet! 664 std::pair<uint64_t, unsigned> Info = CGF.getContext().getTypeInfo(TypeToSize); 665 666 uint64_t Val = E->isSizeOf() ? Info.first : Info.second; 667 Val /= 8; // Return size in bytes, not bits. 668 669 return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); 670} 671 672Value *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 673 Expr *Op = E->getSubExpr(); 674 if (Op->getType()->isAnyComplexType()) 675 return CGF.EmitComplexExpr(Op).first; 676 return Visit(Op); 677} 678Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 679 Expr *Op = E->getSubExpr(); 680 if (Op->getType()->isAnyComplexType()) 681 return CGF.EmitComplexExpr(Op).second; 682 683 // __imag on a scalar returns zero. Emit it the subexpr to ensure side 684 // effects are evaluated. 685 CGF.EmitScalarExpr(Op); 686 return llvm::Constant::getNullValue(ConvertType(E->getType())); 687} 688 689Value *ScalarExprEmitter::VisitUnaryOffsetOf(const UnaryOperator *E) 690{ 691 int64_t Val = E->evaluateOffsetOf(CGF.getContext()); 692 693 assert(E->getType()->isIntegerType() && "Result type must be an integer!"); 694 695 uint32_t ResultWidth = 696 static_cast<uint32_t>(CGF.getContext().getTypeSize(E->getType())); 697 return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val)); 698} 699 700//===----------------------------------------------------------------------===// 701// Binary Operators 702//===----------------------------------------------------------------------===// 703 704BinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 705 BinOpInfo Result; 706 Result.LHS = Visit(E->getLHS()); 707 Result.RHS = Visit(E->getRHS()); 708 Result.Ty = E->getType(); 709 Result.E = E; 710 return Result; 711} 712 713Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 714 Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 715 QualType LHSTy = E->getLHS()->getType(), RHSTy = E->getRHS()->getType(); 716 717 BinOpInfo OpInfo; 718 719 // Load the LHS and RHS operands. 720 LValue LHSLV = EmitLValue(E->getLHS()); 721 OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy); 722 723 // Determine the computation type. If the RHS is complex, then this is one of 724 // the add/sub/mul/div operators. All of these operators can be computed in 725 // with just their real component even though the computation domain really is 726 // complex. 727 QualType ComputeType = E->getComputationType(); 728 729 // If the computation type is complex, then the RHS is complex. Emit the RHS. 730 if (const ComplexType *CT = ComputeType->getAsComplexType()) { 731 ComputeType = CT->getElementType(); 732 733 // Emit the RHS, only keeping the real component. 734 OpInfo.RHS = CGF.EmitComplexExpr(E->getRHS()).first; 735 RHSTy = RHSTy->getAsComplexType()->getElementType(); 736 } else { 737 // Otherwise the RHS is a simple scalar value. 738 OpInfo.RHS = Visit(E->getRHS()); 739 } 740 741 QualType LComputeTy, RComputeTy, ResultTy; 742 743 // Compound assignment does not contain enough information about all 744 // the types involved for pointer arithmetic cases. Figure it out 745 // here for now. 746 if (E->getLHS()->getType()->isPointerType()) { 747 // Pointer arithmetic cases: ptr +=,-= int and ptr -= ptr, 748 assert((E->getOpcode() == BinaryOperator::AddAssign || 749 E->getOpcode() == BinaryOperator::SubAssign) && 750 "Invalid compound assignment operator on pointer type."); 751 LComputeTy = E->getLHS()->getType(); 752 753 if (E->getRHS()->getType()->isPointerType()) { 754 // Degenerate case of (ptr -= ptr) allowed by GCC implicit cast 755 // extension, the conversion from the pointer difference back to 756 // the LHS type is handled at the end. 757 assert(E->getOpcode() == BinaryOperator::SubAssign && 758 "Invalid compound assignment operator on pointer type."); 759 RComputeTy = E->getLHS()->getType(); 760 ResultTy = CGF.getContext().getPointerDiffType(); 761 } else { 762 RComputeTy = E->getRHS()->getType(); 763 ResultTy = LComputeTy; 764 } 765 } else if (E->getRHS()->getType()->isPointerType()) { 766 // Degenerate case of (int += ptr) allowed by GCC implicit cast 767 // extension. 768 assert(E->getOpcode() == BinaryOperator::AddAssign && 769 "Invalid compound assignment operator on pointer type."); 770 LComputeTy = E->getLHS()->getType(); 771 RComputeTy = E->getRHS()->getType(); 772 ResultTy = RComputeTy; 773 } else { 774 LComputeTy = RComputeTy = ResultTy = ComputeType; 775 } 776 777 // Convert the LHS/RHS values to the computation type. 778 OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, LComputeTy); 779 OpInfo.RHS = EmitScalarConversion(OpInfo.RHS, RHSTy, RComputeTy); 780 OpInfo.Ty = ResultTy; 781 OpInfo.E = E; 782 783 // Expand the binary operator. 784 Value *Result = (this->*Func)(OpInfo); 785 786 // Convert the result back to the LHS type. 787 Result = EmitScalarConversion(Result, ResultTy, LHSTy); 788 789 // Store the result value into the LHS lvalue. 790 CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy); 791 792 // For bitfields, we need the value in the bitfield. Note that 793 // property references do not reload their value (even though the 794 // setter may have changed it). 795 // FIXME: This adds an extra bitfield load 796 if (LHSLV.isBitfield()) 797 Result = EmitLoadOfLValue(LHSLV, LHSTy); 798 return Result; 799} 800 801 802Value *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 803 if (Ops.LHS->getType()->isFPOrFPVector()) 804 return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 805 else if (Ops.Ty->isUnsignedIntegerType()) 806 return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 807 else 808 return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 809} 810 811Value *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 812 // Rem in C can't be a floating point type: C99 6.5.5p2. 813 if (Ops.Ty->isUnsignedIntegerType()) 814 return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 815 else 816 return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 817} 818 819 820Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { 821 if (!Ops.Ty->isPointerType()) 822 return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 823 824 // FIXME: What about a pointer to a VLA? 825 Value *Ptr, *Idx; 826 Expr *IdxExp; 827 if (isa<llvm::PointerType>(Ops.LHS->getType())) { // pointer + int 828 Ptr = Ops.LHS; 829 Idx = Ops.RHS; 830 IdxExp = Ops.E->getRHS(); 831 } else { // int + pointer 832 Ptr = Ops.RHS; 833 Idx = Ops.LHS; 834 IdxExp = Ops.E->getLHS(); 835 } 836 837 unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 838 if (Width < CGF.LLVMPointerWidth) { 839 // Zero or sign extend the pointer value based on whether the index is 840 // signed or not. 841 const llvm::Type *IdxType = llvm::IntegerType::get(CGF.LLVMPointerWidth); 842 if (IdxExp->getType()->isSignedIntegerType()) 843 Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 844 else 845 Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 846 } 847 848 return Builder.CreateGEP(Ptr, Idx, "add.ptr"); 849} 850 851Value *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { 852 if (!isa<llvm::PointerType>(Ops.LHS->getType())) 853 return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 854 855 if (!isa<llvm::PointerType>(Ops.RHS->getType())) { 856 // pointer - int 857 Value *Idx = Ops.RHS; 858 unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 859 if (Width < CGF.LLVMPointerWidth) { 860 // Zero or sign extend the pointer value based on whether the index is 861 // signed or not. 862 const llvm::Type *IdxType = llvm::IntegerType::get(CGF.LLVMPointerWidth); 863 if (Ops.E->getRHS()->getType()->isSignedIntegerType()) 864 Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 865 else 866 Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 867 } 868 Idx = Builder.CreateNeg(Idx, "sub.ptr.neg"); 869 870 // FIXME: The pointer could point to a VLA. 871 // The GNU void* - int case is automatically handled here because 872 // our LLVM type for void* is i8*. 873 return Builder.CreateGEP(Ops.LHS, Idx, "sub.ptr"); 874 } else { 875 // pointer - pointer 876 Value *LHS = Ops.LHS; 877 Value *RHS = Ops.RHS; 878 879 const QualType LHSType = Ops.E->getLHS()->getType(); 880 const QualType LHSElementType = LHSType->getAsPointerType()->getPointeeType(); 881 uint64_t ElementSize; 882 883 // Handle GCC extension for pointer arithmetic on void* types. 884 if (LHSElementType->isVoidType()) { 885 ElementSize = 1; 886 } else { 887 ElementSize = CGF.getContext().getTypeSize(LHSElementType) / 8; 888 } 889 890 const llvm::Type *ResultType = ConvertType(Ops.Ty); 891 LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); 892 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 893 Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 894 895 // HACK: LLVM doesn't have an divide instruction that 'knows' there is no 896 // remainder. As such, we handle common power-of-two cases here to generate 897 // better code. See PR2247. 898 if (llvm::isPowerOf2_64(ElementSize)) { 899 Value *ShAmt = 900 llvm::ConstantInt::get(ResultType, llvm::Log2_64(ElementSize)); 901 return Builder.CreateAShr(BytesBetween, ShAmt, "sub.ptr.shr"); 902 } 903 904 // Otherwise, do a full sdiv. 905 Value *BytesPerElt = llvm::ConstantInt::get(ResultType, ElementSize); 906 return Builder.CreateSDiv(BytesBetween, BytesPerElt, "sub.ptr.div"); 907 } 908} 909 910Value *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 911 // LLVM requires the LHS and RHS to be the same type: promote or truncate the 912 // RHS to the same size as the LHS. 913 Value *RHS = Ops.RHS; 914 if (Ops.LHS->getType() != RHS->getType()) 915 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 916 917 return Builder.CreateShl(Ops.LHS, RHS, "shl"); 918} 919 920Value *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 921 // LLVM requires the LHS and RHS to be the same type: promote or truncate the 922 // RHS to the same size as the LHS. 923 Value *RHS = Ops.RHS; 924 if (Ops.LHS->getType() != RHS->getType()) 925 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 926 927 if (Ops.Ty->isUnsignedIntegerType()) 928 return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 929 return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 930} 931 932Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 933 unsigned SICmpOpc, unsigned FCmpOpc) { 934 Value *Result; 935 QualType LHSTy = E->getLHS()->getType(); 936 if (!LHSTy->isAnyComplexType() && !LHSTy->isVectorType()) { 937 Value *LHS = Visit(E->getLHS()); 938 Value *RHS = Visit(E->getRHS()); 939 940 if (LHS->getType()->isFloatingPoint()) { 941 Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 942 LHS, RHS, "cmp"); 943 } else if (LHSTy->isSignedIntegerType()) { 944 Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 945 LHS, RHS, "cmp"); 946 } else { 947 // Unsigned integers and pointers. 948 Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 949 LHS, RHS, "cmp"); 950 } 951 } else if (LHSTy->isVectorType()) { 952 Value *LHS = Visit(E->getLHS()); 953 Value *RHS = Visit(E->getRHS()); 954 955 if (LHS->getType()->isFPOrFPVector()) { 956 Result = Builder.CreateVFCmp((llvm::CmpInst::Predicate)FCmpOpc, 957 LHS, RHS, "cmp"); 958 } else if (LHSTy->isUnsignedIntegerType()) { 959 Result = Builder.CreateVICmp((llvm::CmpInst::Predicate)UICmpOpc, 960 LHS, RHS, "cmp"); 961 } else { 962 // Signed integers and pointers. 963 Result = Builder.CreateVICmp((llvm::CmpInst::Predicate)SICmpOpc, 964 LHS, RHS, "cmp"); 965 } 966 return Result; 967 } else { 968 // Complex Comparison: can only be an equality comparison. 969 CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 970 CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 971 972 QualType CETy = LHSTy->getAsComplexType()->getElementType(); 973 974 Value *ResultR, *ResultI; 975 if (CETy->isRealFloatingType()) { 976 ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 977 LHS.first, RHS.first, "cmp.r"); 978 ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 979 LHS.second, RHS.second, "cmp.i"); 980 } else { 981 // Complex comparisons can only be equality comparisons. As such, signed 982 // and unsigned opcodes are the same. 983 ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 984 LHS.first, RHS.first, "cmp.r"); 985 ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 986 LHS.second, RHS.second, "cmp.i"); 987 } 988 989 if (E->getOpcode() == BinaryOperator::EQ) { 990 Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 991 } else { 992 assert(E->getOpcode() == BinaryOperator::NE && 993 "Complex comparison other than == or != ?"); 994 Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 995 } 996 } 997 998 // ZExt result to int. 999 return Builder.CreateZExt(Result, CGF.LLVMIntTy, "cmp.ext"); 1000} 1001 1002Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 1003 LValue LHS = EmitLValue(E->getLHS()); 1004 Value *RHS = Visit(E->getRHS()); 1005 1006 // Store the value into the LHS. 1007 // FIXME: Volatility! 1008 CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType()); 1009 1010 // For bitfields, we need the value in the bitfield. Note that 1011 // property references do not reload their value (even though the 1012 // setter may have changed it). 1013 // FIXME: This adds an extra bitfield load 1014 if (LHS.isBitfield()) 1015 return EmitLoadOfLValue(LHS, E->getLHS()->getType()); 1016 1017 // Return the RHS. 1018 return RHS; 1019} 1020 1021Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 1022 // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 1023 // If we have 1 && X, just emit X without inserting the control flow. 1024 if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 1025 if (Cond == 1) { // If we have 1 && X, just emit X. 1026 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 1027 // ZExt result to int. 1028 return Builder.CreateZExt(RHSCond, CGF.LLVMIntTy, "land.ext"); 1029 } 1030 1031 // 0 && RHS: If it is safe, just elide the RHS, and return 0. 1032 if (!CGF.ContainsLabel(E->getRHS())) 1033 return llvm::Constant::getNullValue(CGF.LLVMIntTy); 1034 } 1035 1036 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 1037 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 1038 1039 // Branch on the LHS first. If it is false, go to the failure (cont) block. 1040 CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 1041 1042 // Any edges into the ContBlock are now from an (indeterminate number of) 1043 // edges from this first condition. All of these values will be false. Start 1044 // setting up the PHI node in the Cont Block for this. 1045 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::Int1Ty, "", ContBlock); 1046 PN->reserveOperandSpace(2); // Normal case, two inputs. 1047 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 1048 PI != PE; ++PI) 1049 PN->addIncoming(llvm::ConstantInt::getFalse(), *PI); 1050 1051 CGF.EmitBlock(RHSBlock); 1052 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 1053 1054 // Reaquire the RHS block, as there may be subblocks inserted. 1055 RHSBlock = Builder.GetInsertBlock(); 1056 1057 // Emit an unconditional branch from this block to ContBlock. Insert an entry 1058 // into the phi node for the edge with the value of RHSCond. 1059 CGF.EmitBlock(ContBlock); 1060 PN->addIncoming(RHSCond, RHSBlock); 1061 1062 // ZExt result to int. 1063 return Builder.CreateZExt(PN, CGF.LLVMIntTy, "land.ext"); 1064} 1065 1066Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 1067 // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 1068 // If we have 0 || X, just emit X without inserting the control flow. 1069 if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 1070 if (Cond == -1) { // If we have 0 || X, just emit X. 1071 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 1072 // ZExt result to int. 1073 return Builder.CreateZExt(RHSCond, CGF.LLVMIntTy, "lor.ext"); 1074 } 1075 1076 // 1 || RHS: If it is safe, just elide the RHS, and return 0. 1077 if (!CGF.ContainsLabel(E->getRHS())) 1078 return llvm::Constant::getNullValue(CGF.LLVMIntTy); 1079 } 1080 1081 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 1082 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 1083 1084 // Branch on the LHS first. If it is true, go to the success (cont) block. 1085 CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 1086 1087 // Any edges into the ContBlock are now from an (indeterminate number of) 1088 // edges from this first condition. All of these values will be true. Start 1089 // setting up the PHI node in the Cont Block for this. 1090 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::Int1Ty, "", ContBlock); 1091 PN->reserveOperandSpace(2); // Normal case, two inputs. 1092 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 1093 PI != PE; ++PI) 1094 PN->addIncoming(llvm::ConstantInt::getTrue(), *PI); 1095 1096 // Emit the RHS condition as a bool value. 1097 CGF.EmitBlock(RHSBlock); 1098 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 1099 1100 // Reaquire the RHS block, as there may be subblocks inserted. 1101 RHSBlock = Builder.GetInsertBlock(); 1102 1103 // Emit an unconditional branch from this block to ContBlock. Insert an entry 1104 // into the phi node for the edge with the value of RHSCond. 1105 CGF.EmitBlock(ContBlock); 1106 PN->addIncoming(RHSCond, RHSBlock); 1107 1108 // ZExt result to int. 1109 return Builder.CreateZExt(PN, CGF.LLVMIntTy, "lor.ext"); 1110} 1111 1112Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 1113 CGF.EmitStmt(E->getLHS()); 1114 CGF.EnsureInsertPoint(); 1115 return Visit(E->getRHS()); 1116} 1117 1118//===----------------------------------------------------------------------===// 1119// Other Operators 1120//===----------------------------------------------------------------------===// 1121 1122/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 1123/// expression is cheap enough and side-effect-free enough to evaluate 1124/// unconditionally instead of conditionally. This is used to convert control 1125/// flow into selects in some cases. 1126static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E) { 1127 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) 1128 return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr()); 1129 1130 // TODO: Allow anything we can constant fold to an integer or fp constant. 1131 if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) || 1132 isa<FloatingLiteral>(E)) 1133 return true; 1134 1135 // Non-volatile automatic variables too, to get "cond ? X : Y" where 1136 // X and Y are local variables. 1137 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 1138 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 1139 if (VD->hasLocalStorage() && !VD->getType().isVolatileQualified()) 1140 return true; 1141 1142 return false; 1143} 1144 1145 1146Value *ScalarExprEmitter:: 1147VisitConditionalOperator(const ConditionalOperator *E) { 1148 // If the condition constant folds and can be elided, try to avoid emitting 1149 // the condition and the dead arm. 1150 if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getCond())){ 1151 Expr *Live = E->getLHS(), *Dead = E->getRHS(); 1152 if (Cond == -1) 1153 std::swap(Live, Dead); 1154 1155 // If the dead side doesn't have labels we need, and if the Live side isn't 1156 // the gnu missing ?: extension (which we could handle, but don't bother 1157 // to), just emit the Live part. 1158 if ((!Dead || !CGF.ContainsLabel(Dead)) && // No labels in dead part 1159 Live) // Live part isn't missing. 1160 return Visit(Live); 1161 } 1162 1163 1164 // If this is a really simple expression (like x ? 4 : 5), emit this as a 1165 // select instead of as control flow. We can only do this if it is cheap and 1166 // safe to evaluate the LHS and RHS unconditionally. 1167 if (E->getLHS() && isCheapEnoughToEvaluateUnconditionally(E->getLHS()) && 1168 isCheapEnoughToEvaluateUnconditionally(E->getRHS())) { 1169 llvm::Value *CondV = CGF.EvaluateExprAsBool(E->getCond()); 1170 llvm::Value *LHS = Visit(E->getLHS()); 1171 llvm::Value *RHS = Visit(E->getRHS()); 1172 return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 1173 } 1174 1175 1176 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 1177 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 1178 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 1179 Value *CondVal = 0; 1180 1181 // If we have the GNU missing condition extension, evaluate the conditional 1182 // and then convert it to bool the hard way. We do this explicitly 1183 // because we need the unconverted value for the missing middle value of 1184 // the ?:. 1185 if (E->getLHS() == 0) { 1186 CondVal = CGF.EmitScalarExpr(E->getCond()); 1187 Value *CondBoolVal = 1188 CGF.EmitScalarConversion(CondVal, E->getCond()->getType(), 1189 CGF.getContext().BoolTy); 1190 Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock); 1191 } else { 1192 // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for 1193 // the branch on bool. 1194 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 1195 } 1196 1197 CGF.EmitBlock(LHSBlock); 1198 1199 // Handle the GNU extension for missing LHS. 1200 Value *LHS; 1201 if (E->getLHS()) 1202 LHS = Visit(E->getLHS()); 1203 else // Perform promotions, to handle cases like "short ?: int" 1204 LHS = EmitScalarConversion(CondVal, E->getCond()->getType(), E->getType()); 1205 1206 LHSBlock = Builder.GetInsertBlock(); 1207 CGF.EmitBranch(ContBlock); 1208 1209 CGF.EmitBlock(RHSBlock); 1210 1211 Value *RHS = Visit(E->getRHS()); 1212 RHSBlock = Builder.GetInsertBlock(); 1213 CGF.EmitBranch(ContBlock); 1214 1215 CGF.EmitBlock(ContBlock); 1216 1217 if (!LHS || !RHS) { 1218 assert(E->getType()->isVoidType() && "Non-void value should have a value"); 1219 return 0; 1220 } 1221 1222 // Create a PHI node for the real part. 1223 llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond"); 1224 PN->reserveOperandSpace(2); 1225 PN->addIncoming(LHS, LHSBlock); 1226 PN->addIncoming(RHS, RHSBlock); 1227 return PN; 1228} 1229 1230Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 1231 // Emit the LHS or RHS as appropriate. 1232 return 1233 Visit(E->isConditionTrue(CGF.getContext()) ? E->getLHS() : E->getRHS()); 1234} 1235 1236Value *ScalarExprEmitter::VisitOverloadExpr(OverloadExpr *E) { 1237 return CGF.EmitCallExpr(E->getFn(), E->arg_begin(), 1238 E->arg_end(CGF.getContext())).getScalarVal(); 1239} 1240 1241Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 1242 llvm::Value *ArgValue = EmitLValue(VE->getSubExpr()).getAddress(); 1243 1244 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 1245 1246 // If EmitVAArg fails, we fall back to the LLVM instruction. 1247 if (!ArgPtr) 1248 return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 1249 1250 // FIXME: volatile? 1251 return Builder.CreateLoad(ArgPtr); 1252} 1253 1254Value *ScalarExprEmitter::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { 1255 std::string str; 1256 CGF.getContext().getObjCEncodingForType(E->getEncodedType(), str); 1257 1258 llvm::Constant *C = llvm::ConstantArray::get(str); 1259 C = new llvm::GlobalVariable(C->getType(), true, 1260 llvm::GlobalValue::InternalLinkage, 1261 C, ".str", &CGF.CGM.getModule()); 1262 llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty); 1263 llvm::Constant *Zeros[] = { Zero, Zero }; 1264 C = llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2); 1265 1266 return C; 1267} 1268 1269//===----------------------------------------------------------------------===// 1270// Entry Point into this File 1271//===----------------------------------------------------------------------===// 1272 1273/// EmitComplexExpr - Emit the computation of the specified expression of 1274/// complex type, ignoring the result. 1275Value *CodeGenFunction::EmitScalarExpr(const Expr *E) { 1276 assert(E && !hasAggregateLLVMType(E->getType()) && 1277 "Invalid scalar expression to emit"); 1278 1279 return ScalarExprEmitter(*this).Visit(const_cast<Expr*>(E)); 1280} 1281 1282/// EmitScalarConversion - Emit a conversion from the specified type to the 1283/// specified destination type, both of which are LLVM scalar types. 1284Value *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 1285 QualType DstTy) { 1286 assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 1287 "Invalid scalar expression to emit"); 1288 return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 1289} 1290 1291/// EmitComplexToScalarConversion - Emit a conversion from the specified 1292/// complex type to the specified destination type, where the destination 1293/// type is an LLVM scalar type. 1294Value *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 1295 QualType SrcTy, 1296 QualType DstTy) { 1297 assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 1298 "Invalid complex -> scalar conversion"); 1299 return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 1300 DstTy); 1301} 1302 1303Value *CodeGenFunction::EmitShuffleVector(Value* V1, Value *V2, ...) { 1304 assert(V1->getType() == V2->getType() && 1305 "Vector operands must be of the same type"); 1306 unsigned NumElements = 1307 cast<llvm::VectorType>(V1->getType())->getNumElements(); 1308 1309 va_list va; 1310 va_start(va, V2); 1311 1312 llvm::SmallVector<llvm::Constant*, 16> Args; 1313 for (unsigned i = 0; i < NumElements; i++) { 1314 int n = va_arg(va, int); 1315 assert(n >= 0 && n < (int)NumElements * 2 && 1316 "Vector shuffle index out of bounds!"); 1317 Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, n)); 1318 } 1319 1320 const char *Name = va_arg(va, const char *); 1321 va_end(va); 1322 1323 llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 1324 1325 return Builder.CreateShuffleVector(V1, V2, Mask, Name); 1326} 1327 1328llvm::Value *CodeGenFunction::EmitVector(llvm::Value * const *Vals, 1329 unsigned NumVals, bool isSplat) { 1330 llvm::Value *Vec 1331 = llvm::UndefValue::get(llvm::VectorType::get(Vals[0]->getType(), NumVals)); 1332 1333 for (unsigned i = 0, e = NumVals; i != e; ++i) { 1334 llvm::Value *Val = isSplat ? Vals[0] : Vals[i]; 1335 llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i); 1336 Vec = Builder.CreateInsertElement(Vec, Val, Idx, "tmp"); 1337 } 1338 1339 return Vec; 1340} 1341