CGExprScalar.cpp revision 189d6ef40eff11b83b2cda941d5ed89a5cef09b2
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 "clang/Frontend/CodeGenOptions.h" 15#include "CodeGenFunction.h" 16#include "CGCXXABI.h" 17#include "CGObjCRuntime.h" 18#include "CodeGenModule.h" 19#include "CGDebugInfo.h" 20#include "clang/AST/ASTContext.h" 21#include "clang/AST/DeclObjC.h" 22#include "clang/AST/RecordLayout.h" 23#include "clang/AST/StmtVisitor.h" 24#include "clang/Basic/TargetInfo.h" 25#include "llvm/Constants.h" 26#include "llvm/Function.h" 27#include "llvm/GlobalVariable.h" 28#include "llvm/Intrinsics.h" 29#include "llvm/Module.h" 30#include "llvm/Support/CFG.h" 31#include "llvm/Target/TargetData.h" 32#include <cstdarg> 33 34using namespace clang; 35using namespace CodeGen; 36using llvm::Value; 37 38//===----------------------------------------------------------------------===// 39// Scalar Expression Emitter 40//===----------------------------------------------------------------------===// 41 42struct BinOpInfo { 43 Value *LHS; 44 Value *RHS; 45 QualType Ty; // Computation Type. 46 BinaryOperator::Opcode Opcode; // Opcode of BinOp to perform 47 const Expr *E; // Entire expr, for error unsupported. May not be binop. 48}; 49 50namespace { 51class ScalarExprEmitter 52 : public StmtVisitor<ScalarExprEmitter, Value*> { 53 CodeGenFunction &CGF; 54 CGBuilderTy &Builder; 55 bool IgnoreResultAssign; 56 llvm::LLVMContext &VMContext; 57public: 58 59 ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false) 60 : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira), 61 VMContext(cgf.getLLVMContext()) { 62 } 63 64 //===--------------------------------------------------------------------===// 65 // Utilities 66 //===--------------------------------------------------------------------===// 67 68 bool TestAndClearIgnoreResultAssign() { 69 bool I = IgnoreResultAssign; 70 IgnoreResultAssign = false; 71 return I; 72 } 73 74 const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); } 75 LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); } 76 LValue EmitCheckedLValue(const Expr *E) { return CGF.EmitCheckedLValue(E); } 77 78 Value *EmitLoadOfLValue(LValue LV, QualType T) { 79 return CGF.EmitLoadOfLValue(LV, T).getScalarVal(); 80 } 81 82 /// EmitLoadOfLValue - Given an expression with complex type that represents a 83 /// value l-value, this method emits the address of the l-value, then loads 84 /// and returns the result. 85 Value *EmitLoadOfLValue(const Expr *E) { 86 return EmitLoadOfLValue(EmitCheckedLValue(E), E->getType()); 87 } 88 89 /// EmitConversionToBool - Convert the specified expression value to a 90 /// boolean (i1) truth value. This is equivalent to "Val != 0". 91 Value *EmitConversionToBool(Value *Src, QualType DstTy); 92 93 /// EmitScalarConversion - Emit a conversion from the specified type to the 94 /// specified destination type, both of which are LLVM scalar types. 95 Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy); 96 97 /// EmitComplexToScalarConversion - Emit a conversion from the specified 98 /// complex type to the specified destination type, where the destination type 99 /// is an LLVM scalar type. 100 Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 101 QualType SrcTy, QualType DstTy); 102 103 /// EmitNullValue - Emit a value that corresponds to null for the given type. 104 Value *EmitNullValue(QualType Ty); 105 106 //===--------------------------------------------------------------------===// 107 // Visitor Methods 108 //===--------------------------------------------------------------------===// 109 110 Value *Visit(Expr *E) { 111 llvm::DenseMap<const Expr *, llvm::Value *>::iterator I = 112 CGF.ConditionalSaveExprs.find(E); 113 if (I != CGF.ConditionalSaveExprs.end()) 114 return I->second; 115 116 return StmtVisitor<ScalarExprEmitter, Value*>::Visit(E); 117 } 118 119 Value *VisitStmt(Stmt *S) { 120 S->dump(CGF.getContext().getSourceManager()); 121 assert(0 && "Stmt can't have complex result type!"); 122 return 0; 123 } 124 Value *VisitExpr(Expr *S); 125 126 Value *VisitParenExpr(ParenExpr *PE) { 127 return Visit(PE->getSubExpr()); 128 } 129 130 // Leaves. 131 Value *VisitIntegerLiteral(const IntegerLiteral *E) { 132 return llvm::ConstantInt::get(VMContext, E->getValue()); 133 } 134 Value *VisitFloatingLiteral(const FloatingLiteral *E) { 135 return llvm::ConstantFP::get(VMContext, E->getValue()); 136 } 137 Value *VisitCharacterLiteral(const CharacterLiteral *E) { 138 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 139 } 140 Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 141 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 142 } 143 Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) { 144 return EmitNullValue(E->getType()); 145 } 146 Value *VisitGNUNullExpr(const GNUNullExpr *E) { 147 return EmitNullValue(E->getType()); 148 } 149 Value *VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) { 150 return llvm::ConstantInt::get(ConvertType(E->getType()), 151 CGF.getContext().typesAreCompatible( 152 E->getArgType1(), E->getArgType2())); 153 } 154 Value *VisitOffsetOfExpr(OffsetOfExpr *E); 155 Value *VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E); 156 Value *VisitAddrLabelExpr(const AddrLabelExpr *E) { 157 llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel()); 158 return Builder.CreateBitCast(V, ConvertType(E->getType())); 159 } 160 161 // l-values. 162 Value *VisitDeclRefExpr(DeclRefExpr *E) { 163 Expr::EvalResult Result; 164 if (!E->Evaluate(Result, CGF.getContext())) 165 return EmitLoadOfLValue(E); 166 167 assert(!Result.HasSideEffects && "Constant declref with side-effect?!"); 168 169 llvm::Constant *C; 170 if (Result.Val.isInt()) { 171 C = llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 172 } else if (Result.Val.isFloat()) { 173 C = llvm::ConstantFP::get(VMContext, Result.Val.getFloat()); 174 } else { 175 return EmitLoadOfLValue(E); 176 } 177 178 // Make sure we emit a debug reference to the global variable. 179 if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) { 180 if (!CGF.getContext().DeclMustBeEmitted(VD)) 181 CGF.EmitDeclRefExprDbgValue(E, C); 182 } else if (isa<EnumConstantDecl>(E->getDecl())) { 183 CGF.EmitDeclRefExprDbgValue(E, C); 184 } 185 186 return C; 187 } 188 Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 189 return CGF.EmitObjCSelectorExpr(E); 190 } 191 Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 192 return CGF.EmitObjCProtocolExpr(E); 193 } 194 Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 195 return EmitLoadOfLValue(E); 196 } 197 Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 198 return EmitLoadOfLValue(E); 199 } 200 Value *VisitObjCImplicitSetterGetterRefExpr( 201 ObjCImplicitSetterGetterRefExpr *E) { 202 return EmitLoadOfLValue(E); 203 } 204 Value *VisitObjCMessageExpr(ObjCMessageExpr *E) { 205 return CGF.EmitObjCMessageExpr(E).getScalarVal(); 206 } 207 208 Value *VisitObjCIsaExpr(ObjCIsaExpr *E) { 209 LValue LV = CGF.EmitObjCIsaExpr(E); 210 Value *V = CGF.EmitLoadOfLValue(LV, E->getType()).getScalarVal(); 211 return V; 212 } 213 214 Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 215 Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E); 216 Value *VisitMemberExpr(MemberExpr *E); 217 Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); } 218 Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 219 return EmitLoadOfLValue(E); 220 } 221 222 Value *VisitInitListExpr(InitListExpr *E); 223 224 Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) { 225 return CGF.CGM.EmitNullConstant(E->getType()); 226 } 227 Value *VisitCastExpr(CastExpr *E) { 228 // Make sure to evaluate VLA bounds now so that we have them for later. 229 if (E->getType()->isVariablyModifiedType()) 230 CGF.EmitVLASize(E->getType()); 231 232 return EmitCastExpr(E); 233 } 234 Value *EmitCastExpr(CastExpr *E); 235 236 Value *VisitCallExpr(const CallExpr *E) { 237 if (E->getCallReturnType()->isReferenceType()) 238 return EmitLoadOfLValue(E); 239 240 return CGF.EmitCallExpr(E).getScalarVal(); 241 } 242 243 Value *VisitStmtExpr(const StmtExpr *E); 244 245 Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E); 246 247 // Unary Operators. 248 Value *VisitUnaryPostDec(const UnaryOperator *E) { 249 LValue LV = EmitLValue(E->getSubExpr()); 250 return EmitScalarPrePostIncDec(E, LV, false, false); 251 } 252 Value *VisitUnaryPostInc(const UnaryOperator *E) { 253 LValue LV = EmitLValue(E->getSubExpr()); 254 return EmitScalarPrePostIncDec(E, LV, true, false); 255 } 256 Value *VisitUnaryPreDec(const UnaryOperator *E) { 257 LValue LV = EmitLValue(E->getSubExpr()); 258 return EmitScalarPrePostIncDec(E, LV, false, true); 259 } 260 Value *VisitUnaryPreInc(const UnaryOperator *E) { 261 LValue LV = EmitLValue(E->getSubExpr()); 262 return EmitScalarPrePostIncDec(E, LV, true, true); 263 } 264 265 llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 266 bool isInc, bool isPre); 267 268 269 Value *VisitUnaryAddrOf(const UnaryOperator *E) { 270 // If the sub-expression is an instance member reference, 271 // EmitDeclRefLValue will magically emit it with the appropriate 272 // value as the "address". 273 return EmitLValue(E->getSubExpr()).getAddress(); 274 } 275 Value *VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 276 Value *VisitUnaryPlus(const UnaryOperator *E) { 277 // This differs from gcc, though, most likely due to a bug in gcc. 278 TestAndClearIgnoreResultAssign(); 279 return Visit(E->getSubExpr()); 280 } 281 Value *VisitUnaryMinus (const UnaryOperator *E); 282 Value *VisitUnaryNot (const UnaryOperator *E); 283 Value *VisitUnaryLNot (const UnaryOperator *E); 284 Value *VisitUnaryReal (const UnaryOperator *E); 285 Value *VisitUnaryImag (const UnaryOperator *E); 286 Value *VisitUnaryExtension(const UnaryOperator *E) { 287 return Visit(E->getSubExpr()); 288 } 289 290 // C++ 291 Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 292 return Visit(DAE->getExpr()); 293 } 294 Value *VisitCXXThisExpr(CXXThisExpr *TE) { 295 return CGF.LoadCXXThis(); 296 } 297 298 Value *VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { 299 return CGF.EmitCXXExprWithTemporaries(E).getScalarVal(); 300 } 301 Value *VisitCXXNewExpr(const CXXNewExpr *E) { 302 return CGF.EmitCXXNewExpr(E); 303 } 304 Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) { 305 CGF.EmitCXXDeleteExpr(E); 306 return 0; 307 } 308 Value *VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 309 return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue()); 310 } 311 312 Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) { 313 // C++ [expr.pseudo]p1: 314 // The result shall only be used as the operand for the function call 315 // operator (), and the result of such a call has type void. The only 316 // effect is the evaluation of the postfix-expression before the dot or 317 // arrow. 318 CGF.EmitScalarExpr(E->getBase()); 319 return 0; 320 } 321 322 Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 323 return EmitNullValue(E->getType()); 324 } 325 326 Value *VisitCXXThrowExpr(const CXXThrowExpr *E) { 327 CGF.EmitCXXThrowExpr(E); 328 return 0; 329 } 330 331 Value *VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) { 332 return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue()); 333 } 334 335 // Binary Operators. 336 Value *EmitMul(const BinOpInfo &Ops) { 337 if (Ops.Ty->hasSignedIntegerRepresentation()) { 338 switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 339 case LangOptions::SOB_Undefined: 340 return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul"); 341 case LangOptions::SOB_Defined: 342 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 343 case LangOptions::SOB_Trapping: 344 return EmitOverflowCheckedBinOp(Ops); 345 } 346 } 347 348 if (Ops.LHS->getType()->isFPOrFPVectorTy()) 349 return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul"); 350 return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 351 } 352 bool isTrapvOverflowBehavior() { 353 return CGF.getContext().getLangOptions().getSignedOverflowBehavior() 354 == LangOptions::SOB_Trapping; 355 } 356 /// Create a binary op that checks for overflow. 357 /// Currently only supports +, - and *. 358 Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); 359 // Emit the overflow BB when -ftrapv option is activated. 360 void EmitOverflowBB(llvm::BasicBlock *overflowBB) { 361 Builder.SetInsertPoint(overflowBB); 362 llvm::Function *Trap = CGF.CGM.getIntrinsic(llvm::Intrinsic::trap); 363 Builder.CreateCall(Trap); 364 Builder.CreateUnreachable(); 365 } 366 // Check for undefined division and modulus behaviors. 367 void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops, 368 llvm::Value *Zero,bool isDiv); 369 Value *EmitDiv(const BinOpInfo &Ops); 370 Value *EmitRem(const BinOpInfo &Ops); 371 Value *EmitAdd(const BinOpInfo &Ops); 372 Value *EmitSub(const BinOpInfo &Ops); 373 Value *EmitShl(const BinOpInfo &Ops); 374 Value *EmitShr(const BinOpInfo &Ops); 375 Value *EmitAnd(const BinOpInfo &Ops) { 376 return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 377 } 378 Value *EmitXor(const BinOpInfo &Ops) { 379 return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 380 } 381 Value *EmitOr (const BinOpInfo &Ops) { 382 return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 383 } 384 385 BinOpInfo EmitBinOps(const BinaryOperator *E); 386 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 387 Value *(ScalarExprEmitter::*F)(const BinOpInfo &), 388 Value *&Result); 389 390 Value *EmitCompoundAssign(const CompoundAssignOperator *E, 391 Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 392 393 // Binary operators and binary compound assignment operators. 394#define HANDLEBINOP(OP) \ 395 Value *VisitBin ## OP(const BinaryOperator *E) { \ 396 return Emit ## OP(EmitBinOps(E)); \ 397 } \ 398 Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 399 return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 400 } 401 HANDLEBINOP(Mul) 402 HANDLEBINOP(Div) 403 HANDLEBINOP(Rem) 404 HANDLEBINOP(Add) 405 HANDLEBINOP(Sub) 406 HANDLEBINOP(Shl) 407 HANDLEBINOP(Shr) 408 HANDLEBINOP(And) 409 HANDLEBINOP(Xor) 410 HANDLEBINOP(Or) 411#undef HANDLEBINOP 412 413 // Comparisons. 414 Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 415 unsigned SICmpOpc, unsigned FCmpOpc); 416#define VISITCOMP(CODE, UI, SI, FP) \ 417 Value *VisitBin##CODE(const BinaryOperator *E) { \ 418 return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 419 llvm::FCmpInst::FP); } 420 VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT) 421 VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT) 422 VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE) 423 VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE) 424 VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ) 425 VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE) 426#undef VISITCOMP 427 428 Value *VisitBinAssign (const BinaryOperator *E); 429 430 Value *VisitBinLAnd (const BinaryOperator *E); 431 Value *VisitBinLOr (const BinaryOperator *E); 432 Value *VisitBinComma (const BinaryOperator *E); 433 434 Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); } 435 Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); } 436 437 // Other Operators. 438 Value *VisitBlockExpr(const BlockExpr *BE); 439 Value *VisitConditionalOperator(const ConditionalOperator *CO); 440 Value *VisitChooseExpr(ChooseExpr *CE); 441 Value *VisitVAArgExpr(VAArgExpr *VE); 442 Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 443 return CGF.EmitObjCStringLiteral(E); 444 } 445}; 446} // end anonymous namespace. 447 448//===----------------------------------------------------------------------===// 449// Utilities 450//===----------------------------------------------------------------------===// 451 452/// EmitConversionToBool - Convert the specified expression value to a 453/// boolean (i1) truth value. This is equivalent to "Val != 0". 454Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 455 assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs"); 456 457 if (SrcType->isRealFloatingType()) { 458 // Compare against 0.0 for fp scalars. 459 llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 460 return Builder.CreateFCmpUNE(Src, Zero, "tobool"); 461 } 462 463 if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType)) 464 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT); 465 466 assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 467 "Unknown scalar type to convert"); 468 469 // Because of the type rules of C, we often end up computing a logical value, 470 // then zero extending it to int, then wanting it as a logical value again. 471 // Optimize this common case. 472 if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(Src)) { 473 if (ZI->getOperand(0)->getType() == 474 llvm::Type::getInt1Ty(CGF.getLLVMContext())) { 475 Value *Result = ZI->getOperand(0); 476 // If there aren't any more uses, zap the instruction to save space. 477 // Note that there can be more uses, for example if this 478 // is the result of an assignment. 479 if (ZI->use_empty()) 480 ZI->eraseFromParent(); 481 return Result; 482 } 483 } 484 485 // Compare against an integer or pointer null. 486 llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 487 return Builder.CreateICmpNE(Src, Zero, "tobool"); 488} 489 490/// EmitScalarConversion - Emit a conversion from the specified type to the 491/// specified destination type, both of which are LLVM scalar types. 492Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 493 QualType DstType) { 494 SrcType = CGF.getContext().getCanonicalType(SrcType); 495 DstType = CGF.getContext().getCanonicalType(DstType); 496 if (SrcType == DstType) return Src; 497 498 if (DstType->isVoidType()) return 0; 499 500 // Handle conversions to bool first, they are special: comparisons against 0. 501 if (DstType->isBooleanType()) 502 return EmitConversionToBool(Src, SrcType); 503 504 const llvm::Type *DstTy = ConvertType(DstType); 505 506 // Ignore conversions like int -> uint. 507 if (Src->getType() == DstTy) 508 return Src; 509 510 // Handle pointer conversions next: pointers can only be converted to/from 511 // other pointers and integers. Check for pointer types in terms of LLVM, as 512 // some native types (like Obj-C id) may map to a pointer type. 513 if (isa<llvm::PointerType>(DstTy)) { 514 // The source value may be an integer, or a pointer. 515 if (isa<llvm::PointerType>(Src->getType())) 516 return Builder.CreateBitCast(Src, DstTy, "conv"); 517 518 assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 519 // First, convert to the correct width so that we control the kind of 520 // extension. 521 const llvm::Type *MiddleTy = CGF.IntPtrTy; 522 bool InputSigned = SrcType->isSignedIntegerType(); 523 llvm::Value* IntResult = 524 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 525 // Then, cast to pointer. 526 return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 527 } 528 529 if (isa<llvm::PointerType>(Src->getType())) { 530 // Must be an ptr to int cast. 531 assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 532 return Builder.CreatePtrToInt(Src, DstTy, "conv"); 533 } 534 535 // A scalar can be splatted to an extended vector of the same element type 536 if (DstType->isExtVectorType() && !SrcType->isVectorType()) { 537 // Cast the scalar to element type 538 QualType EltTy = DstType->getAs<ExtVectorType>()->getElementType(); 539 llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 540 541 // Insert the element in element zero of an undef vector 542 llvm::Value *UnV = llvm::UndefValue::get(DstTy); 543 llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 544 UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 545 546 // Splat the element across to all elements 547 llvm::SmallVector<llvm::Constant*, 16> Args; 548 unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 549 for (unsigned i = 0; i < NumElements; i++) 550 Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 0)); 551 552 llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 553 llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 554 return Yay; 555 } 556 557 // Allow bitcast from vector to integer/fp of the same size. 558 if (isa<llvm::VectorType>(Src->getType()) || 559 isa<llvm::VectorType>(DstTy)) 560 return Builder.CreateBitCast(Src, DstTy, "conv"); 561 562 // Finally, we have the arithmetic types: real int/float. 563 if (isa<llvm::IntegerType>(Src->getType())) { 564 bool InputSigned = SrcType->isSignedIntegerType(); 565 if (isa<llvm::IntegerType>(DstTy)) 566 return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 567 else if (InputSigned) 568 return Builder.CreateSIToFP(Src, DstTy, "conv"); 569 else 570 return Builder.CreateUIToFP(Src, DstTy, "conv"); 571 } 572 573 assert(Src->getType()->isFloatingPointTy() && "Unknown real conversion"); 574 if (isa<llvm::IntegerType>(DstTy)) { 575 if (DstType->isSignedIntegerType()) 576 return Builder.CreateFPToSI(Src, DstTy, "conv"); 577 else 578 return Builder.CreateFPToUI(Src, DstTy, "conv"); 579 } 580 581 assert(DstTy->isFloatingPointTy() && "Unknown real conversion"); 582 if (DstTy->getTypeID() < Src->getType()->getTypeID()) 583 return Builder.CreateFPTrunc(Src, DstTy, "conv"); 584 else 585 return Builder.CreateFPExt(Src, DstTy, "conv"); 586} 587 588/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 589/// type to the specified destination type, where the destination type is an 590/// LLVM scalar type. 591Value *ScalarExprEmitter:: 592EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 593 QualType SrcTy, QualType DstTy) { 594 // Get the source element type. 595 SrcTy = SrcTy->getAs<ComplexType>()->getElementType(); 596 597 // Handle conversions to bool first, they are special: comparisons against 0. 598 if (DstTy->isBooleanType()) { 599 // Complex != 0 -> (Real != 0) | (Imag != 0) 600 Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 601 Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 602 return Builder.CreateOr(Src.first, Src.second, "tobool"); 603 } 604 605 // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 606 // the imaginary part of the complex value is discarded and the value of the 607 // real part is converted according to the conversion rules for the 608 // corresponding real type. 609 return EmitScalarConversion(Src.first, SrcTy, DstTy); 610} 611 612Value *ScalarExprEmitter::EmitNullValue(QualType Ty) { 613 if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) 614 return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 615 616 return llvm::Constant::getNullValue(ConvertType(Ty)); 617} 618 619//===----------------------------------------------------------------------===// 620// Visitor Methods 621//===----------------------------------------------------------------------===// 622 623Value *ScalarExprEmitter::VisitExpr(Expr *E) { 624 CGF.ErrorUnsupported(E, "scalar expression"); 625 if (E->getType()->isVoidType()) 626 return 0; 627 return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 628} 629 630Value *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 631 // Vector Mask Case 632 if (E->getNumSubExprs() == 2 || 633 (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { 634 Value *LHS = CGF.EmitScalarExpr(E->getExpr(0)); 635 Value *RHS = CGF.EmitScalarExpr(E->getExpr(1)); 636 Value *Mask; 637 638 const llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType()); 639 unsigned LHSElts = LTy->getNumElements(); 640 641 if (E->getNumSubExprs() == 3) { 642 Mask = CGF.EmitScalarExpr(E->getExpr(2)); 643 644 // Shuffle LHS & RHS into one input vector. 645 llvm::SmallVector<llvm::Constant*, 32> concat; 646 for (unsigned i = 0; i != LHSElts; ++i) { 647 concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i)); 648 concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i+1)); 649 } 650 651 Value* CV = llvm::ConstantVector::get(concat.begin(), concat.size()); 652 LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); 653 LHSElts *= 2; 654 } else { 655 Mask = RHS; 656 } 657 658 const llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType()); 659 llvm::Constant* EltMask; 660 661 // Treat vec3 like vec4. 662 if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) 663 EltMask = llvm::ConstantInt::get(MTy->getElementType(), 664 (1 << llvm::Log2_32(LHSElts+2))-1); 665 else if ((LHSElts == 3) && (E->getNumSubExprs() == 2)) 666 EltMask = llvm::ConstantInt::get(MTy->getElementType(), 667 (1 << llvm::Log2_32(LHSElts+1))-1); 668 else 669 EltMask = llvm::ConstantInt::get(MTy->getElementType(), 670 (1 << llvm::Log2_32(LHSElts))-1); 671 672 // Mask off the high bits of each shuffle index. 673 llvm::SmallVector<llvm::Constant *, 32> MaskV; 674 for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) 675 MaskV.push_back(EltMask); 676 677 Value* MaskBits = llvm::ConstantVector::get(MaskV.begin(), MaskV.size()); 678 Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); 679 680 // newv = undef 681 // mask = mask & maskbits 682 // for each elt 683 // n = extract mask i 684 // x = extract val n 685 // newv = insert newv, x, i 686 const llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(), 687 MTy->getNumElements()); 688 Value* NewV = llvm::UndefValue::get(RTy); 689 for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) { 690 Value *Indx = llvm::ConstantInt::get(CGF.Int32Ty, i); 691 Indx = Builder.CreateExtractElement(Mask, Indx, "shuf_idx"); 692 Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext"); 693 694 // Handle vec3 special since the index will be off by one for the RHS. 695 if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { 696 Value *cmpIndx, *newIndx; 697 cmpIndx = Builder.CreateICmpUGT(Indx, 698 llvm::ConstantInt::get(CGF.Int32Ty, 3), 699 "cmp_shuf_idx"); 700 newIndx = Builder.CreateSub(Indx, llvm::ConstantInt::get(CGF.Int32Ty,1), 701 "shuf_idx_adj"); 702 Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx"); 703 } 704 Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt"); 705 NewV = Builder.CreateInsertElement(NewV, VExt, Indx, "shuf_ins"); 706 } 707 return NewV; 708 } 709 710 Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 711 Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 712 713 // Handle vec3 special since the index will be off by one for the RHS. 714 llvm::SmallVector<llvm::Constant*, 32> indices; 715 for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 716 llvm::Constant *C = cast<llvm::Constant>(CGF.EmitScalarExpr(E->getExpr(i))); 717 const llvm::VectorType *VTy = cast<llvm::VectorType>(V1->getType()); 718 if (VTy->getNumElements() == 3) { 719 if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C)) { 720 uint64_t cVal = CI->getZExtValue(); 721 if (cVal > 3) { 722 C = llvm::ConstantInt::get(C->getType(), cVal-1); 723 } 724 } 725 } 726 indices.push_back(C); 727 } 728 729 Value* SV = llvm::ConstantVector::get(indices.begin(), indices.size()); 730 return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 731} 732Value *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) { 733 Expr::EvalResult Result; 734 if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 735 if (E->isArrow()) 736 CGF.EmitScalarExpr(E->getBase()); 737 else 738 EmitLValue(E->getBase()); 739 return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 740 } 741 742 // Emit debug info for aggregate now, if it was delayed to reduce 743 // debug info size. 744 CGDebugInfo *DI = CGF.getDebugInfo(); 745 if (DI && CGF.CGM.getCodeGenOpts().LimitDebugInfo) { 746 QualType PQTy = E->getBase()->IgnoreParenImpCasts()->getType(); 747 if (const PointerType * PTy = dyn_cast<PointerType>(PQTy)) 748 if (FieldDecl *M = dyn_cast<FieldDecl>(E->getMemberDecl())) 749 DI->getOrCreateRecordType(PTy->getPointeeType(), 750 M->getParent()->getLocation()); 751 } 752 return EmitLoadOfLValue(E); 753} 754 755Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 756 TestAndClearIgnoreResultAssign(); 757 758 // Emit subscript expressions in rvalue context's. For most cases, this just 759 // loads the lvalue formed by the subscript expr. However, we have to be 760 // careful, because the base of a vector subscript is occasionally an rvalue, 761 // so we can't get it as an lvalue. 762 if (!E->getBase()->getType()->isVectorType()) 763 return EmitLoadOfLValue(E); 764 765 // Handle the vector case. The base must be a vector, the index must be an 766 // integer value. 767 Value *Base = Visit(E->getBase()); 768 Value *Idx = Visit(E->getIdx()); 769 bool IdxSigned = E->getIdx()->getType()->isSignedIntegerType(); 770 Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast"); 771 return Builder.CreateExtractElement(Base, Idx, "vecext"); 772} 773 774static llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, 775 unsigned Off, const llvm::Type *I32Ty) { 776 int MV = SVI->getMaskValue(Idx); 777 if (MV == -1) 778 return llvm::UndefValue::get(I32Ty); 779 return llvm::ConstantInt::get(I32Ty, Off+MV); 780} 781 782Value *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { 783 bool Ignore = TestAndClearIgnoreResultAssign(); 784 (void)Ignore; 785 assert (Ignore == false && "init list ignored"); 786 unsigned NumInitElements = E->getNumInits(); 787 788 if (E->hadArrayRangeDesignator()) 789 CGF.ErrorUnsupported(E, "GNU array range designator extension"); 790 791 const llvm::VectorType *VType = 792 dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 793 794 // We have a scalar in braces. Just use the first element. 795 if (!VType) 796 return Visit(E->getInit(0)); 797 798 unsigned ResElts = VType->getNumElements(); 799 800 // Loop over initializers collecting the Value for each, and remembering 801 // whether the source was swizzle (ExtVectorElementExpr). This will allow 802 // us to fold the shuffle for the swizzle into the shuffle for the vector 803 // initializer, since LLVM optimizers generally do not want to touch 804 // shuffles. 805 unsigned CurIdx = 0; 806 bool VIsUndefShuffle = false; 807 llvm::Value *V = llvm::UndefValue::get(VType); 808 for (unsigned i = 0; i != NumInitElements; ++i) { 809 Expr *IE = E->getInit(i); 810 Value *Init = Visit(IE); 811 llvm::SmallVector<llvm::Constant*, 16> Args; 812 813 const llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType()); 814 815 // Handle scalar elements. If the scalar initializer is actually one 816 // element of a different vector of the same width, use shuffle instead of 817 // extract+insert. 818 if (!VVT) { 819 if (isa<ExtVectorElementExpr>(IE)) { 820 llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init); 821 822 if (EI->getVectorOperandType()->getNumElements() == ResElts) { 823 llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand()); 824 Value *LHS = 0, *RHS = 0; 825 if (CurIdx == 0) { 826 // insert into undef -> shuffle (src, undef) 827 Args.push_back(C); 828 for (unsigned j = 1; j != ResElts; ++j) 829 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 830 831 LHS = EI->getVectorOperand(); 832 RHS = V; 833 VIsUndefShuffle = true; 834 } else if (VIsUndefShuffle) { 835 // insert into undefshuffle && size match -> shuffle (v, src) 836 llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V); 837 for (unsigned j = 0; j != CurIdx; ++j) 838 Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty)); 839 Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 840 ResElts + C->getZExtValue())); 841 for (unsigned j = CurIdx + 1; j != ResElts; ++j) 842 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 843 844 LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 845 RHS = EI->getVectorOperand(); 846 VIsUndefShuffle = false; 847 } 848 if (!Args.empty()) { 849 llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 850 V = Builder.CreateShuffleVector(LHS, RHS, Mask); 851 ++CurIdx; 852 continue; 853 } 854 } 855 } 856 Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 857 V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 858 VIsUndefShuffle = false; 859 ++CurIdx; 860 continue; 861 } 862 863 unsigned InitElts = VVT->getNumElements(); 864 865 // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's 866 // input is the same width as the vector being constructed, generate an 867 // optimized shuffle of the swizzle input into the result. 868 unsigned Offset = (CurIdx == 0) ? 0 : ResElts; 869 if (isa<ExtVectorElementExpr>(IE)) { 870 llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init); 871 Value *SVOp = SVI->getOperand(0); 872 const llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType()); 873 874 if (OpTy->getNumElements() == ResElts) { 875 for (unsigned j = 0; j != CurIdx; ++j) { 876 // If the current vector initializer is a shuffle with undef, merge 877 // this shuffle directly into it. 878 if (VIsUndefShuffle) { 879 Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0, 880 CGF.Int32Ty)); 881 } else { 882 Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 883 } 884 } 885 for (unsigned j = 0, je = InitElts; j != je; ++j) 886 Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty)); 887 for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 888 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 889 890 if (VIsUndefShuffle) 891 V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 892 893 Init = SVOp; 894 } 895 } 896 897 // Extend init to result vector length, and then shuffle its contribution 898 // to the vector initializer into V. 899 if (Args.empty()) { 900 for (unsigned j = 0; j != InitElts; ++j) 901 Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 902 for (unsigned j = InitElts; j != ResElts; ++j) 903 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 904 llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 905 Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), 906 Mask, "vext"); 907 908 Args.clear(); 909 for (unsigned j = 0; j != CurIdx; ++j) 910 Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 911 for (unsigned j = 0; j != InitElts; ++j) 912 Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j+Offset)); 913 for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 914 Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 915 } 916 917 // If V is undef, make sure it ends up on the RHS of the shuffle to aid 918 // merging subsequent shuffles into this one. 919 if (CurIdx == 0) 920 std::swap(V, Init); 921 llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 922 V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit"); 923 VIsUndefShuffle = isa<llvm::UndefValue>(Init); 924 CurIdx += InitElts; 925 } 926 927 // FIXME: evaluate codegen vs. shuffling against constant null vector. 928 // Emit remaining default initializers. 929 const llvm::Type *EltTy = VType->getElementType(); 930 931 // Emit remaining default initializers 932 for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { 933 Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 934 llvm::Value *Init = llvm::Constant::getNullValue(EltTy); 935 V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 936 } 937 return V; 938} 939 940static bool ShouldNullCheckClassCastValue(const CastExpr *CE) { 941 const Expr *E = CE->getSubExpr(); 942 943 if (CE->getCastKind() == CK_UncheckedDerivedToBase) 944 return false; 945 946 if (isa<CXXThisExpr>(E)) { 947 // We always assume that 'this' is never null. 948 return false; 949 } 950 951 if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) { 952 // And that glvalue casts are never null. 953 if (ICE->getValueKind() != VK_RValue) 954 return false; 955 } 956 957 return true; 958} 959 960// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 961// have to handle a more broad range of conversions than explicit casts, as they 962// handle things like function to ptr-to-function decay etc. 963Value *ScalarExprEmitter::EmitCastExpr(CastExpr *CE) { 964 Expr *E = CE->getSubExpr(); 965 QualType DestTy = CE->getType(); 966 CastKind Kind = CE->getCastKind(); 967 968 if (!DestTy->isVoidType()) 969 TestAndClearIgnoreResultAssign(); 970 971 // Since almost all cast kinds apply to scalars, this switch doesn't have 972 // a default case, so the compiler will warn on a missing case. The cases 973 // are in the same order as in the CastKind enum. 974 switch (Kind) { 975 case CK_Unknown: 976 // FIXME: All casts should have a known kind! 977 //assert(0 && "Unknown cast kind!"); 978 break; 979 980 case CK_LValueBitCast: 981 case CK_ObjCObjectLValueCast: { 982 Value *V = EmitLValue(E).getAddress(); 983 V = Builder.CreateBitCast(V, 984 ConvertType(CGF.getContext().getPointerType(DestTy))); 985 return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), DestTy); 986 } 987 988 case CK_AnyPointerToObjCPointerCast: 989 case CK_AnyPointerToBlockPointerCast: 990 case CK_BitCast: { 991 Value *Src = Visit(const_cast<Expr*>(E)); 992 return Builder.CreateBitCast(Src, ConvertType(DestTy)); 993 } 994 case CK_NoOp: 995 case CK_UserDefinedConversion: 996 return Visit(const_cast<Expr*>(E)); 997 998 case CK_BaseToDerived: { 999 const CXXRecordDecl *DerivedClassDecl = 1000 DestTy->getCXXRecordDeclForPointerType(); 1001 1002 return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl, 1003 CE->path_begin(), CE->path_end(), 1004 ShouldNullCheckClassCastValue(CE)); 1005 } 1006 case CK_UncheckedDerivedToBase: 1007 case CK_DerivedToBase: { 1008 const RecordType *DerivedClassTy = 1009 E->getType()->getAs<PointerType>()->getPointeeType()->getAs<RecordType>(); 1010 CXXRecordDecl *DerivedClassDecl = 1011 cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1012 1013 return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, 1014 CE->path_begin(), CE->path_end(), 1015 ShouldNullCheckClassCastValue(CE)); 1016 } 1017 case CK_Dynamic: { 1018 Value *V = Visit(const_cast<Expr*>(E)); 1019 const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE); 1020 return CGF.EmitDynamicCast(V, DCE); 1021 } 1022 case CK_ToUnion: 1023 assert(0 && "Should be unreachable!"); 1024 break; 1025 1026 case CK_ArrayToPointerDecay: { 1027 assert(E->getType()->isArrayType() && 1028 "Array to pointer decay must have array source type!"); 1029 1030 Value *V = EmitLValue(E).getAddress(); // Bitfields can't be arrays. 1031 1032 // Note that VLA pointers are always decayed, so we don't need to do 1033 // anything here. 1034 if (!E->getType()->isVariableArrayType()) { 1035 assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 1036 assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 1037 ->getElementType()) && 1038 "Expected pointer to array"); 1039 V = Builder.CreateStructGEP(V, 0, "arraydecay"); 1040 } 1041 1042 return V; 1043 } 1044 case CK_FunctionToPointerDecay: 1045 return EmitLValue(E).getAddress(); 1046 1047 case CK_NullToMemberPointer: { 1048 // If the subexpression's type is the C++0x nullptr_t, emit the 1049 // subexpression, which may have side effects. 1050 if (E->getType()->isNullPtrType()) 1051 (void) Visit(E); 1052 1053 const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>(); 1054 return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 1055 } 1056 1057 case CK_BaseToDerivedMemberPointer: 1058 case CK_DerivedToBaseMemberPointer: { 1059 Value *Src = Visit(E); 1060 1061 // Note that the AST doesn't distinguish between checked and 1062 // unchecked member pointer conversions, so we always have to 1063 // implement checked conversions here. This is inefficient when 1064 // actual control flow may be required in order to perform the 1065 // check, which it is for data member pointers (but not member 1066 // function pointers on Itanium and ARM). 1067 return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src); 1068 } 1069 1070 1071 case CK_ConstructorConversion: 1072 assert(0 && "Should be unreachable!"); 1073 break; 1074 1075 case CK_IntegralToPointer: { 1076 Value *Src = Visit(const_cast<Expr*>(E)); 1077 1078 // First, convert to the correct width so that we control the kind of 1079 // extension. 1080 const llvm::Type *MiddleTy = CGF.IntPtrTy; 1081 bool InputSigned = E->getType()->isSignedIntegerType(); 1082 llvm::Value* IntResult = 1083 Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 1084 1085 return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy)); 1086 } 1087 case CK_PointerToIntegral: { 1088 Value *Src = Visit(const_cast<Expr*>(E)); 1089 1090 // Handle conversion to bool correctly. 1091 if (DestTy->isBooleanType()) 1092 return EmitScalarConversion(Src, E->getType(), DestTy); 1093 1094 return Builder.CreatePtrToInt(Src, ConvertType(DestTy)); 1095 } 1096 case CK_ToVoid: { 1097 if (E->Classify(CGF.getContext()).isGLValue()) { 1098 LValue LV = CGF.EmitLValue(E); 1099 if (LV.isPropertyRef()) 1100 CGF.EmitLoadOfPropertyRefLValue(LV, E->getType()); 1101 else if (LV.isKVCRef()) 1102 CGF.EmitLoadOfKVCRefLValue(LV, E->getType()); 1103 } 1104 else 1105 CGF.EmitAnyExpr(E, AggValueSlot::ignored(), true); 1106 return 0; 1107 } 1108 case CK_VectorSplat: { 1109 const llvm::Type *DstTy = ConvertType(DestTy); 1110 Value *Elt = Visit(const_cast<Expr*>(E)); 1111 1112 // Insert the element in element zero of an undef vector 1113 llvm::Value *UnV = llvm::UndefValue::get(DstTy); 1114 llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 1115 UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 1116 1117 // Splat the element across to all elements 1118 llvm::SmallVector<llvm::Constant*, 16> Args; 1119 unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 1120 for (unsigned i = 0; i < NumElements; i++) 1121 Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 0)); 1122 1123 llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 1124 llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 1125 return Yay; 1126 } 1127 case CK_IntegralCast: 1128 case CK_IntegralToFloating: 1129 case CK_FloatingToIntegral: 1130 case CK_FloatingCast: 1131 return EmitScalarConversion(Visit(E), E->getType(), DestTy); 1132 1133 case CK_MemberPointerToBoolean: { 1134 llvm::Value *MemPtr = Visit(E); 1135 const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>(); 1136 return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT); 1137 } 1138 } 1139 1140 // Handle cases where the source is an non-complex type. 1141 1142 if (!CGF.hasAggregateLLVMType(E->getType())) { 1143 Value *Src = Visit(const_cast<Expr*>(E)); 1144 1145 // Use EmitScalarConversion to perform the conversion. 1146 return EmitScalarConversion(Src, E->getType(), DestTy); 1147 } 1148 1149 if (E->getType()->isAnyComplexType()) { 1150 // Handle cases where the source is a complex type. 1151 bool IgnoreImag = true; 1152 bool IgnoreImagAssign = true; 1153 bool IgnoreReal = IgnoreResultAssign; 1154 bool IgnoreRealAssign = IgnoreResultAssign; 1155 if (DestTy->isBooleanType()) 1156 IgnoreImagAssign = IgnoreImag = false; 1157 else if (DestTy->isVoidType()) { 1158 IgnoreReal = IgnoreImag = false; 1159 IgnoreRealAssign = IgnoreImagAssign = true; 1160 } 1161 CodeGenFunction::ComplexPairTy V 1162 = CGF.EmitComplexExpr(E, IgnoreReal, IgnoreImag, IgnoreRealAssign, 1163 IgnoreImagAssign); 1164 return EmitComplexToScalarConversion(V, E->getType(), DestTy); 1165 } 1166 1167 // Okay, this is a cast from an aggregate. It must be a cast to void. Just 1168 // evaluate the result and return. 1169 CGF.EmitAggExpr(E, AggValueSlot::ignored(), true); 1170 return 0; 1171} 1172 1173Value *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 1174 return CGF.EmitCompoundStmt(*E->getSubStmt(), 1175 !E->getType()->isVoidType()).getScalarVal(); 1176} 1177 1178Value *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 1179 llvm::Value *V = CGF.GetAddrOfBlockDecl(E); 1180 if (E->getType().isObjCGCWeak()) 1181 return CGF.CGM.getObjCRuntime().EmitObjCWeakRead(CGF, V); 1182 return CGF.EmitLoadOfScalar(V, false, 0, E->getType()); 1183} 1184 1185//===----------------------------------------------------------------------===// 1186// Unary Operators 1187//===----------------------------------------------------------------------===// 1188 1189llvm::Value *ScalarExprEmitter:: 1190EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 1191 bool isInc, bool isPre) { 1192 1193 QualType ValTy = E->getSubExpr()->getType(); 1194 llvm::Value *InVal = EmitLoadOfLValue(LV, ValTy); 1195 1196 int AmountVal = isInc ? 1 : -1; 1197 1198 if (ValTy->isPointerType() && 1199 ValTy->getAs<PointerType>()->isVariableArrayType()) { 1200 // The amount of the addition/subtraction needs to account for the VLA size 1201 CGF.ErrorUnsupported(E, "VLA pointer inc/dec"); 1202 } 1203 1204 llvm::Value *NextVal; 1205 if (const llvm::PointerType *PT = 1206 dyn_cast<llvm::PointerType>(InVal->getType())) { 1207 llvm::Constant *Inc = llvm::ConstantInt::get(CGF.Int32Ty, AmountVal); 1208 if (!isa<llvm::FunctionType>(PT->getElementType())) { 1209 QualType PTEE = ValTy->getPointeeType(); 1210 if (const ObjCObjectType *OIT = PTEE->getAs<ObjCObjectType>()) { 1211 // Handle interface types, which are not represented with a concrete 1212 // type. 1213 int size = CGF.getContext().getTypeSize(OIT) / 8; 1214 if (!isInc) 1215 size = -size; 1216 Inc = llvm::ConstantInt::get(Inc->getType(), size); 1217 const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1218 InVal = Builder.CreateBitCast(InVal, i8Ty); 1219 NextVal = Builder.CreateGEP(InVal, Inc, "add.ptr"); 1220 llvm::Value *lhs = LV.getAddress(); 1221 lhs = Builder.CreateBitCast(lhs, llvm::PointerType::getUnqual(i8Ty)); 1222 LV = CGF.MakeAddrLValue(lhs, ValTy); 1223 } else 1224 NextVal = Builder.CreateInBoundsGEP(InVal, Inc, "ptrincdec"); 1225 } else { 1226 const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1227 NextVal = Builder.CreateBitCast(InVal, i8Ty, "tmp"); 1228 NextVal = Builder.CreateGEP(NextVal, Inc, "ptrincdec"); 1229 NextVal = Builder.CreateBitCast(NextVal, InVal->getType()); 1230 } 1231 } else if (InVal->getType()->isIntegerTy(1) && isInc) { 1232 // Bool++ is an interesting case, due to promotion rules, we get: 1233 // Bool++ -> Bool = Bool+1 -> Bool = (int)Bool+1 -> 1234 // Bool = ((int)Bool+1) != 0 1235 // An interesting aspect of this is that increment is always true. 1236 // Decrement does not have this property. 1237 NextVal = llvm::ConstantInt::getTrue(VMContext); 1238 } else if (isa<llvm::IntegerType>(InVal->getType())) { 1239 NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal); 1240 1241 if (!ValTy->isSignedIntegerType()) 1242 // Unsigned integer inc is always two's complement. 1243 NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1244 else { 1245 switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1246 case LangOptions::SOB_Undefined: 1247 NextVal = Builder.CreateNSWAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1248 break; 1249 case LangOptions::SOB_Defined: 1250 NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1251 break; 1252 case LangOptions::SOB_Trapping: 1253 BinOpInfo BinOp; 1254 BinOp.LHS = InVal; 1255 BinOp.RHS = NextVal; 1256 BinOp.Ty = E->getType(); 1257 BinOp.Opcode = BO_Add; 1258 BinOp.E = E; 1259 NextVal = EmitOverflowCheckedBinOp(BinOp); 1260 break; 1261 } 1262 } 1263 } else { 1264 // Add the inc/dec to the real part. 1265 if (InVal->getType()->isFloatTy()) 1266 NextVal = 1267 llvm::ConstantFP::get(VMContext, 1268 llvm::APFloat(static_cast<float>(AmountVal))); 1269 else if (InVal->getType()->isDoubleTy()) 1270 NextVal = 1271 llvm::ConstantFP::get(VMContext, 1272 llvm::APFloat(static_cast<double>(AmountVal))); 1273 else { 1274 llvm::APFloat F(static_cast<float>(AmountVal)); 1275 bool ignored; 1276 F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 1277 &ignored); 1278 NextVal = llvm::ConstantFP::get(VMContext, F); 1279 } 1280 NextVal = Builder.CreateFAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1281 } 1282 1283 // Store the updated result through the lvalue. 1284 if (LV.isBitField()) 1285 CGF.EmitStoreThroughBitfieldLValue(RValue::get(NextVal), LV, ValTy, &NextVal); 1286 else 1287 CGF.EmitStoreThroughLValue(RValue::get(NextVal), LV, ValTy); 1288 1289 // If this is a postinc, return the value read from memory, otherwise use the 1290 // updated value. 1291 return isPre ? NextVal : InVal; 1292} 1293 1294 1295 1296Value *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 1297 TestAndClearIgnoreResultAssign(); 1298 // Emit unary minus with EmitSub so we handle overflow cases etc. 1299 BinOpInfo BinOp; 1300 BinOp.RHS = Visit(E->getSubExpr()); 1301 1302 if (BinOp.RHS->getType()->isFPOrFPVectorTy()) 1303 BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType()); 1304 else 1305 BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType()); 1306 BinOp.Ty = E->getType(); 1307 BinOp.Opcode = BO_Sub; 1308 BinOp.E = E; 1309 return EmitSub(BinOp); 1310} 1311 1312Value *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 1313 TestAndClearIgnoreResultAssign(); 1314 Value *Op = Visit(E->getSubExpr()); 1315 return Builder.CreateNot(Op, "neg"); 1316} 1317 1318Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 1319 // Compare operand to zero. 1320 Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 1321 1322 // Invert value. 1323 // TODO: Could dynamically modify easy computations here. For example, if 1324 // the operand is an icmp ne, turn into icmp eq. 1325 BoolVal = Builder.CreateNot(BoolVal, "lnot"); 1326 1327 // ZExt result to the expr type. 1328 return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext"); 1329} 1330 1331Value *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) { 1332 // Try folding the offsetof to a constant. 1333 Expr::EvalResult EvalResult; 1334 if (E->Evaluate(EvalResult, CGF.getContext())) 1335 return llvm::ConstantInt::get(VMContext, EvalResult.Val.getInt()); 1336 1337 // Loop over the components of the offsetof to compute the value. 1338 unsigned n = E->getNumComponents(); 1339 const llvm::Type* ResultType = ConvertType(E->getType()); 1340 llvm::Value* Result = llvm::Constant::getNullValue(ResultType); 1341 QualType CurrentType = E->getTypeSourceInfo()->getType(); 1342 for (unsigned i = 0; i != n; ++i) { 1343 OffsetOfExpr::OffsetOfNode ON = E->getComponent(i); 1344 llvm::Value *Offset = 0; 1345 switch (ON.getKind()) { 1346 case OffsetOfExpr::OffsetOfNode::Array: { 1347 // Compute the index 1348 Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex()); 1349 llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr); 1350 bool IdxSigned = IdxExpr->getType()->isSignedIntegerType(); 1351 Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv"); 1352 1353 // Save the element type 1354 CurrentType = 1355 CGF.getContext().getAsArrayType(CurrentType)->getElementType(); 1356 1357 // Compute the element size 1358 llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType, 1359 CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity()); 1360 1361 // Multiply out to compute the result 1362 Offset = Builder.CreateMul(Idx, ElemSize); 1363 break; 1364 } 1365 1366 case OffsetOfExpr::OffsetOfNode::Field: { 1367 FieldDecl *MemberDecl = ON.getField(); 1368 RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 1369 const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 1370 1371 // Compute the index of the field in its parent. 1372 unsigned i = 0; 1373 // FIXME: It would be nice if we didn't have to loop here! 1374 for (RecordDecl::field_iterator Field = RD->field_begin(), 1375 FieldEnd = RD->field_end(); 1376 Field != FieldEnd; (void)++Field, ++i) { 1377 if (*Field == MemberDecl) 1378 break; 1379 } 1380 assert(i < RL.getFieldCount() && "offsetof field in wrong type"); 1381 1382 // Compute the offset to the field 1383 int64_t OffsetInt = RL.getFieldOffset(i) / 1384 CGF.getContext().getCharWidth(); 1385 Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 1386 1387 // Save the element type. 1388 CurrentType = MemberDecl->getType(); 1389 break; 1390 } 1391 1392 case OffsetOfExpr::OffsetOfNode::Identifier: 1393 llvm_unreachable("dependent __builtin_offsetof"); 1394 1395 case OffsetOfExpr::OffsetOfNode::Base: { 1396 if (ON.getBase()->isVirtual()) { 1397 CGF.ErrorUnsupported(E, "virtual base in offsetof"); 1398 continue; 1399 } 1400 1401 RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 1402 const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 1403 1404 // Save the element type. 1405 CurrentType = ON.getBase()->getType(); 1406 1407 // Compute the offset to the base. 1408 const RecordType *BaseRT = CurrentType->getAs<RecordType>(); 1409 CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl()); 1410 int64_t OffsetInt = RL.getBaseClassOffset(BaseRD) / 1411 CGF.getContext().getCharWidth(); 1412 Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 1413 break; 1414 } 1415 } 1416 Result = Builder.CreateAdd(Result, Offset); 1417 } 1418 return Result; 1419} 1420 1421/// VisitSizeOfAlignOfExpr - Return the size or alignment of the type of 1422/// argument of the sizeof expression as an integer. 1423Value * 1424ScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) { 1425 QualType TypeToSize = E->getTypeOfArgument(); 1426 if (E->isSizeOf()) { 1427 if (const VariableArrayType *VAT = 1428 CGF.getContext().getAsVariableArrayType(TypeToSize)) { 1429 if (E->isArgumentType()) { 1430 // sizeof(type) - make sure to emit the VLA size. 1431 CGF.EmitVLASize(TypeToSize); 1432 } else { 1433 // C99 6.5.3.4p2: If the argument is an expression of type 1434 // VLA, it is evaluated. 1435 CGF.EmitAnyExpr(E->getArgumentExpr()); 1436 } 1437 1438 return CGF.GetVLASize(VAT); 1439 } 1440 } 1441 1442 // If this isn't sizeof(vla), the result must be constant; use the constant 1443 // folding logic so we don't have to duplicate it here. 1444 Expr::EvalResult Result; 1445 E->Evaluate(Result, CGF.getContext()); 1446 return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 1447} 1448 1449Value *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 1450 Expr *Op = E->getSubExpr(); 1451 if (Op->getType()->isAnyComplexType()) 1452 return CGF.EmitComplexExpr(Op, false, true, false, true).first; 1453 return Visit(Op); 1454} 1455Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 1456 Expr *Op = E->getSubExpr(); 1457 if (Op->getType()->isAnyComplexType()) 1458 return CGF.EmitComplexExpr(Op, true, false, true, false).second; 1459 1460 // __imag on a scalar returns zero. Emit the subexpr to ensure side 1461 // effects are evaluated, but not the actual value. 1462 if (E->isLvalue(CGF.getContext()) == Expr::LV_Valid) 1463 CGF.EmitLValue(Op); 1464 else 1465 CGF.EmitScalarExpr(Op, true); 1466 return llvm::Constant::getNullValue(ConvertType(E->getType())); 1467} 1468 1469//===----------------------------------------------------------------------===// 1470// Binary Operators 1471//===----------------------------------------------------------------------===// 1472 1473BinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 1474 TestAndClearIgnoreResultAssign(); 1475 BinOpInfo Result; 1476 Result.LHS = Visit(E->getLHS()); 1477 Result.RHS = Visit(E->getRHS()); 1478 Result.Ty = E->getType(); 1479 Result.Opcode = E->getOpcode(); 1480 Result.E = E; 1481 return Result; 1482} 1483 1484LValue ScalarExprEmitter::EmitCompoundAssignLValue( 1485 const CompoundAssignOperator *E, 1486 Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), 1487 Value *&Result) { 1488 QualType LHSTy = E->getLHS()->getType(); 1489 BinOpInfo OpInfo; 1490 1491 if (E->getComputationResultType()->isAnyComplexType()) { 1492 // This needs to go through the complex expression emitter, but it's a tad 1493 // complicated to do that... I'm leaving it out for now. (Note that we do 1494 // actually need the imaginary part of the RHS for multiplication and 1495 // division.) 1496 CGF.ErrorUnsupported(E, "complex compound assignment"); 1497 Result = llvm::UndefValue::get(CGF.ConvertType(E->getType())); 1498 return LValue(); 1499 } 1500 1501 // Emit the RHS first. __block variables need to have the rhs evaluated 1502 // first, plus this should improve codegen a little. 1503 OpInfo.RHS = Visit(E->getRHS()); 1504 OpInfo.Ty = E->getComputationResultType(); 1505 OpInfo.Opcode = E->getOpcode(); 1506 OpInfo.E = E; 1507 // Load/convert the LHS. 1508 LValue LHSLV = EmitCheckedLValue(E->getLHS()); 1509 OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy); 1510 OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 1511 E->getComputationLHSType()); 1512 1513 // Expand the binary operator. 1514 Result = (this->*Func)(OpInfo); 1515 1516 // Convert the result back to the LHS type. 1517 Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 1518 1519 // Store the result value into the LHS lvalue. Bit-fields are handled 1520 // specially because the result is altered by the store, i.e., [C99 6.5.16p1] 1521 // 'An assignment expression has the value of the left operand after the 1522 // assignment...'. 1523 if (LHSLV.isBitField()) 1524 CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy, 1525 &Result); 1526 else 1527 CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy); 1528 1529 return LHSLV; 1530} 1531 1532Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 1533 Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 1534 bool Ignore = TestAndClearIgnoreResultAssign(); 1535 Value *RHS; 1536 LValue LHS = EmitCompoundAssignLValue(E, Func, RHS); 1537 1538 // If the result is clearly ignored, return now. 1539 if (Ignore) 1540 return 0; 1541 1542 // Objective-C property assignment never reloads the value following a store. 1543 if (LHS.isPropertyRef() || LHS.isKVCRef()) 1544 return RHS; 1545 1546 // If the lvalue is non-volatile, return the computed value of the assignment. 1547 if (!LHS.isVolatileQualified()) 1548 return RHS; 1549 1550 // Otherwise, reload the value. 1551 return EmitLoadOfLValue(LHS, E->getType()); 1552} 1553 1554void ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck( 1555 const BinOpInfo &Ops, 1556 llvm::Value *Zero, bool isDiv) { 1557 llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 1558 llvm::BasicBlock *contBB = 1559 CGF.createBasicBlock(isDiv ? "div.cont" : "rem.cont", CGF.CurFn); 1560 1561 const llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType()); 1562 1563 if (Ops.Ty->hasSignedIntegerRepresentation()) { 1564 llvm::Value *IntMin = 1565 llvm::ConstantInt::get(VMContext, 1566 llvm::APInt::getSignedMinValue(Ty->getBitWidth())); 1567 llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL); 1568 1569 llvm::Value *Cond1 = Builder.CreateICmpEQ(Ops.RHS, Zero); 1570 llvm::Value *LHSCmp = Builder.CreateICmpEQ(Ops.LHS, IntMin); 1571 llvm::Value *RHSCmp = Builder.CreateICmpEQ(Ops.RHS, NegOne); 1572 llvm::Value *Cond2 = Builder.CreateAnd(LHSCmp, RHSCmp, "and"); 1573 Builder.CreateCondBr(Builder.CreateOr(Cond1, Cond2, "or"), 1574 overflowBB, contBB); 1575 } else { 1576 CGF.Builder.CreateCondBr(Builder.CreateICmpEQ(Ops.RHS, Zero), 1577 overflowBB, contBB); 1578 } 1579 EmitOverflowBB(overflowBB); 1580 Builder.SetInsertPoint(contBB); 1581} 1582 1583Value *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 1584 if (isTrapvOverflowBehavior()) { 1585 llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 1586 1587 if (Ops.Ty->isIntegerType()) 1588 EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true); 1589 else if (Ops.Ty->isRealFloatingType()) { 1590 llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", 1591 CGF.CurFn); 1592 llvm::BasicBlock *DivCont = CGF.createBasicBlock("div.cont", CGF.CurFn); 1593 CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero), 1594 overflowBB, DivCont); 1595 EmitOverflowBB(overflowBB); 1596 Builder.SetInsertPoint(DivCont); 1597 } 1598 } 1599 if (Ops.LHS->getType()->isFPOrFPVectorTy()) 1600 return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 1601 else if (Ops.Ty->hasUnsignedIntegerRepresentation()) 1602 return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 1603 else 1604 return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 1605} 1606 1607Value *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 1608 // Rem in C can't be a floating point type: C99 6.5.5p2. 1609 if (isTrapvOverflowBehavior()) { 1610 llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 1611 1612 if (Ops.Ty->isIntegerType()) 1613 EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false); 1614 } 1615 1616 if (Ops.Ty->isUnsignedIntegerType()) 1617 return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 1618 else 1619 return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 1620} 1621 1622Value *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 1623 unsigned IID; 1624 unsigned OpID = 0; 1625 1626 switch (Ops.Opcode) { 1627 case BO_Add: 1628 case BO_AddAssign: 1629 OpID = 1; 1630 IID = llvm::Intrinsic::sadd_with_overflow; 1631 break; 1632 case BO_Sub: 1633 case BO_SubAssign: 1634 OpID = 2; 1635 IID = llvm::Intrinsic::ssub_with_overflow; 1636 break; 1637 case BO_Mul: 1638 case BO_MulAssign: 1639 OpID = 3; 1640 IID = llvm::Intrinsic::smul_with_overflow; 1641 break; 1642 default: 1643 assert(false && "Unsupported operation for overflow detection"); 1644 IID = 0; 1645 } 1646 OpID <<= 1; 1647 OpID |= 1; 1648 1649 const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 1650 1651 llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1); 1652 1653 Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 1654 Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 1655 Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 1656 1657 // Branch in case of overflow. 1658 llvm::BasicBlock *initialBB = Builder.GetInsertBlock(); 1659 llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 1660 llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn); 1661 1662 Builder.CreateCondBr(overflow, overflowBB, continueBB); 1663 1664 // Handle overflow with llvm.trap. 1665 const std::string *handlerName = 1666 &CGF.getContext().getLangOptions().OverflowHandler; 1667 if (handlerName->empty()) { 1668 EmitOverflowBB(overflowBB); 1669 Builder.SetInsertPoint(continueBB); 1670 return result; 1671 } 1672 1673 // If an overflow handler is set, then we want to call it and then use its 1674 // result, if it returns. 1675 Builder.SetInsertPoint(overflowBB); 1676 1677 // Get the overflow handler. 1678 const llvm::Type *Int8Ty = llvm::Type::getInt8Ty(VMContext); 1679 std::vector<const llvm::Type*> argTypes; 1680 argTypes.push_back(CGF.Int64Ty); argTypes.push_back(CGF.Int64Ty); 1681 argTypes.push_back(Int8Ty); argTypes.push_back(Int8Ty); 1682 llvm::FunctionType *handlerTy = 1683 llvm::FunctionType::get(CGF.Int64Ty, argTypes, true); 1684 llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName); 1685 1686 // Sign extend the args to 64-bit, so that we can use the same handler for 1687 // all types of overflow. 1688 llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty); 1689 llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty); 1690 1691 // Call the handler with the two arguments, the operation, and the size of 1692 // the result. 1693 llvm::Value *handlerResult = Builder.CreateCall4(handler, lhs, rhs, 1694 Builder.getInt8(OpID), 1695 Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())); 1696 1697 // Truncate the result back to the desired size. 1698 handlerResult = Builder.CreateTrunc(handlerResult, opTy); 1699 Builder.CreateBr(continueBB); 1700 1701 Builder.SetInsertPoint(continueBB); 1702 llvm::PHINode *phi = Builder.CreatePHI(opTy); 1703 phi->reserveOperandSpace(2); 1704 phi->addIncoming(result, initialBB); 1705 phi->addIncoming(handlerResult, overflowBB); 1706 1707 return phi; 1708} 1709 1710Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { 1711 if (!Ops.Ty->isAnyPointerType()) { 1712 if (Ops.Ty->hasSignedIntegerRepresentation()) { 1713 switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1714 case LangOptions::SOB_Undefined: 1715 return Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "add"); 1716 case LangOptions::SOB_Defined: 1717 return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 1718 case LangOptions::SOB_Trapping: 1719 return EmitOverflowCheckedBinOp(Ops); 1720 } 1721 } 1722 1723 if (Ops.LHS->getType()->isFPOrFPVectorTy()) 1724 return Builder.CreateFAdd(Ops.LHS, Ops.RHS, "add"); 1725 1726 return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 1727 } 1728 1729 // Must have binary (not unary) expr here. Unary pointer decrement doesn't 1730 // use this path. 1731 const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 1732 1733 if (Ops.Ty->isPointerType() && 1734 Ops.Ty->getAs<PointerType>()->isVariableArrayType()) { 1735 // The amount of the addition needs to account for the VLA size 1736 CGF.ErrorUnsupported(BinOp, "VLA pointer addition"); 1737 } 1738 1739 Value *Ptr, *Idx; 1740 Expr *IdxExp; 1741 const PointerType *PT = BinOp->getLHS()->getType()->getAs<PointerType>(); 1742 const ObjCObjectPointerType *OPT = 1743 BinOp->getLHS()->getType()->getAs<ObjCObjectPointerType>(); 1744 if (PT || OPT) { 1745 Ptr = Ops.LHS; 1746 Idx = Ops.RHS; 1747 IdxExp = BinOp->getRHS(); 1748 } else { // int + pointer 1749 PT = BinOp->getRHS()->getType()->getAs<PointerType>(); 1750 OPT = BinOp->getRHS()->getType()->getAs<ObjCObjectPointerType>(); 1751 assert((PT || OPT) && "Invalid add expr"); 1752 Ptr = Ops.RHS; 1753 Idx = Ops.LHS; 1754 IdxExp = BinOp->getLHS(); 1755 } 1756 1757 unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 1758 if (Width < CGF.LLVMPointerWidth) { 1759 // Zero or sign extend the pointer value based on whether the index is 1760 // signed or not. 1761 const llvm::Type *IdxType = CGF.IntPtrTy; 1762 if (IdxExp->getType()->isSignedIntegerType()) 1763 Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 1764 else 1765 Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 1766 } 1767 const QualType ElementType = PT ? PT->getPointeeType() : OPT->getPointeeType(); 1768 // Handle interface types, which are not represented with a concrete type. 1769 if (const ObjCObjectType *OIT = ElementType->getAs<ObjCObjectType>()) { 1770 llvm::Value *InterfaceSize = 1771 llvm::ConstantInt::get(Idx->getType(), 1772 CGF.getContext().getTypeSizeInChars(OIT).getQuantity()); 1773 Idx = Builder.CreateMul(Idx, InterfaceSize); 1774 const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1775 Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 1776 Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 1777 return Builder.CreateBitCast(Res, Ptr->getType()); 1778 } 1779 1780 // Explicitly handle GNU void* and function pointer arithmetic extensions. The 1781 // GNU void* casts amount to no-ops since our void* type is i8*, but this is 1782 // future proof. 1783 if (ElementType->isVoidType() || ElementType->isFunctionType()) { 1784 const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1785 Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 1786 Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 1787 return Builder.CreateBitCast(Res, Ptr->getType()); 1788 } 1789 1790 return Builder.CreateInBoundsGEP(Ptr, Idx, "add.ptr"); 1791} 1792 1793Value *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { 1794 if (!isa<llvm::PointerType>(Ops.LHS->getType())) { 1795 if (Ops.Ty->hasSignedIntegerRepresentation()) { 1796 switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1797 case LangOptions::SOB_Undefined: 1798 return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub"); 1799 case LangOptions::SOB_Defined: 1800 return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 1801 case LangOptions::SOB_Trapping: 1802 return EmitOverflowCheckedBinOp(Ops); 1803 } 1804 } 1805 1806 if (Ops.LHS->getType()->isFPOrFPVectorTy()) 1807 return Builder.CreateFSub(Ops.LHS, Ops.RHS, "sub"); 1808 1809 return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 1810 } 1811 1812 // Must have binary (not unary) expr here. Unary pointer increment doesn't 1813 // use this path. 1814 const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 1815 1816 if (BinOp->getLHS()->getType()->isPointerType() && 1817 BinOp->getLHS()->getType()->getAs<PointerType>()->isVariableArrayType()) { 1818 // The amount of the addition needs to account for the VLA size for 1819 // ptr-int 1820 // The amount of the division needs to account for the VLA size for 1821 // ptr-ptr. 1822 CGF.ErrorUnsupported(BinOp, "VLA pointer subtraction"); 1823 } 1824 1825 const QualType LHSType = BinOp->getLHS()->getType(); 1826 const QualType LHSElementType = LHSType->getPointeeType(); 1827 if (!isa<llvm::PointerType>(Ops.RHS->getType())) { 1828 // pointer - int 1829 Value *Idx = Ops.RHS; 1830 unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 1831 if (Width < CGF.LLVMPointerWidth) { 1832 // Zero or sign extend the pointer value based on whether the index is 1833 // signed or not. 1834 const llvm::Type *IdxType = CGF.IntPtrTy; 1835 if (BinOp->getRHS()->getType()->isSignedIntegerType()) 1836 Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 1837 else 1838 Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 1839 } 1840 Idx = Builder.CreateNeg(Idx, "sub.ptr.neg"); 1841 1842 // Handle interface types, which are not represented with a concrete type. 1843 if (const ObjCObjectType *OIT = LHSElementType->getAs<ObjCObjectType>()) { 1844 llvm::Value *InterfaceSize = 1845 llvm::ConstantInt::get(Idx->getType(), 1846 CGF.getContext(). 1847 getTypeSizeInChars(OIT).getQuantity()); 1848 Idx = Builder.CreateMul(Idx, InterfaceSize); 1849 const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1850 Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1851 Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr"); 1852 return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1853 } 1854 1855 // Explicitly handle GNU void* and function pointer arithmetic 1856 // extensions. The GNU void* casts amount to no-ops since our void* type is 1857 // i8*, but this is future proof. 1858 if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 1859 const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1860 Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1861 Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr"); 1862 return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1863 } 1864 1865 return Builder.CreateInBoundsGEP(Ops.LHS, Idx, "sub.ptr"); 1866 } else { 1867 // pointer - pointer 1868 Value *LHS = Ops.LHS; 1869 Value *RHS = Ops.RHS; 1870 1871 CharUnits ElementSize; 1872 1873 // Handle GCC extension for pointer arithmetic on void* and function pointer 1874 // types. 1875 if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 1876 ElementSize = CharUnits::One(); 1877 } else { 1878 ElementSize = CGF.getContext().getTypeSizeInChars(LHSElementType); 1879 } 1880 1881 const llvm::Type *ResultType = ConvertType(Ops.Ty); 1882 LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); 1883 RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 1884 Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 1885 1886 // Optimize out the shift for element size of 1. 1887 if (ElementSize.isOne()) 1888 return BytesBetween; 1889 1890 // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 1891 // pointer difference in C is only defined in the case where both operands 1892 // are pointing to elements of an array. 1893 Value *BytesPerElt = 1894 llvm::ConstantInt::get(ResultType, ElementSize.getQuantity()); 1895 return Builder.CreateExactSDiv(BytesBetween, BytesPerElt, "sub.ptr.div"); 1896 } 1897} 1898 1899Value *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 1900 // LLVM requires the LHS and RHS to be the same type: promote or truncate the 1901 // RHS to the same size as the LHS. 1902 Value *RHS = Ops.RHS; 1903 if (Ops.LHS->getType() != RHS->getType()) 1904 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1905 1906 if (CGF.CatchUndefined 1907 && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1908 unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1909 llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1910 CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1911 llvm::ConstantInt::get(RHS->getType(), Width)), 1912 Cont, CGF.getTrapBB()); 1913 CGF.EmitBlock(Cont); 1914 } 1915 1916 return Builder.CreateShl(Ops.LHS, RHS, "shl"); 1917} 1918 1919Value *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 1920 // LLVM requires the LHS and RHS to be the same type: promote or truncate the 1921 // RHS to the same size as the LHS. 1922 Value *RHS = Ops.RHS; 1923 if (Ops.LHS->getType() != RHS->getType()) 1924 RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1925 1926 if (CGF.CatchUndefined 1927 && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1928 unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1929 llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1930 CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1931 llvm::ConstantInt::get(RHS->getType(), Width)), 1932 Cont, CGF.getTrapBB()); 1933 CGF.EmitBlock(Cont); 1934 } 1935 1936 if (Ops.Ty->hasUnsignedIntegerRepresentation()) 1937 return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 1938 return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 1939} 1940 1941Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 1942 unsigned SICmpOpc, unsigned FCmpOpc) { 1943 TestAndClearIgnoreResultAssign(); 1944 Value *Result; 1945 QualType LHSTy = E->getLHS()->getType(); 1946 if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) { 1947 assert(E->getOpcode() == BO_EQ || 1948 E->getOpcode() == BO_NE); 1949 Value *LHS = CGF.EmitScalarExpr(E->getLHS()); 1950 Value *RHS = CGF.EmitScalarExpr(E->getRHS()); 1951 Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison( 1952 CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE); 1953 } else if (!LHSTy->isAnyComplexType()) { 1954 Value *LHS = Visit(E->getLHS()); 1955 Value *RHS = Visit(E->getRHS()); 1956 1957 if (LHS->getType()->isFPOrFPVectorTy()) { 1958 Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 1959 LHS, RHS, "cmp"); 1960 } else if (LHSTy->hasSignedIntegerRepresentation()) { 1961 Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 1962 LHS, RHS, "cmp"); 1963 } else { 1964 // Unsigned integers and pointers. 1965 Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1966 LHS, RHS, "cmp"); 1967 } 1968 1969 // If this is a vector comparison, sign extend the result to the appropriate 1970 // vector integer type and return it (don't convert to bool). 1971 if (LHSTy->isVectorType()) 1972 return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 1973 1974 } else { 1975 // Complex Comparison: can only be an equality comparison. 1976 CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 1977 CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 1978 1979 QualType CETy = LHSTy->getAs<ComplexType>()->getElementType(); 1980 1981 Value *ResultR, *ResultI; 1982 if (CETy->isRealFloatingType()) { 1983 ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 1984 LHS.first, RHS.first, "cmp.r"); 1985 ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 1986 LHS.second, RHS.second, "cmp.i"); 1987 } else { 1988 // Complex comparisons can only be equality comparisons. As such, signed 1989 // and unsigned opcodes are the same. 1990 ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1991 LHS.first, RHS.first, "cmp.r"); 1992 ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1993 LHS.second, RHS.second, "cmp.i"); 1994 } 1995 1996 if (E->getOpcode() == BO_EQ) { 1997 Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 1998 } else { 1999 assert(E->getOpcode() == BO_NE && 2000 "Complex comparison other than == or != ?"); 2001 Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 2002 } 2003 } 2004 2005 return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 2006} 2007 2008Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 2009 bool Ignore = TestAndClearIgnoreResultAssign(); 2010 2011 // __block variables need to have the rhs evaluated first, plus this should 2012 // improve codegen just a little. 2013 Value *RHS = Visit(E->getRHS()); 2014 LValue LHS = EmitCheckedLValue(E->getLHS()); 2015 2016 // Store the value into the LHS. Bit-fields are handled specially 2017 // because the result is altered by the store, i.e., [C99 6.5.16p1] 2018 // 'An assignment expression has the value of the left operand after 2019 // the assignment...'. 2020 if (LHS.isBitField()) 2021 CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType(), 2022 &RHS); 2023 else 2024 CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType()); 2025 2026 // If the result is clearly ignored, return now. 2027 if (Ignore) 2028 return 0; 2029 2030 // Objective-C property assignment never reloads the value following a store. 2031 if (LHS.isPropertyRef() || LHS.isKVCRef()) 2032 return RHS; 2033 2034 // If the lvalue is non-volatile, return the computed value of the assignment. 2035 if (!LHS.isVolatileQualified()) 2036 return RHS; 2037 2038 // Otherwise, reload the value. 2039 return EmitLoadOfLValue(LHS, E->getType()); 2040} 2041 2042Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 2043 const llvm::Type *ResTy = ConvertType(E->getType()); 2044 2045 // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 2046 // If we have 1 && X, just emit X without inserting the control flow. 2047 if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 2048 if (Cond == 1) { // If we have 1 && X, just emit X. 2049 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2050 // ZExt result to int or bool. 2051 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 2052 } 2053 2054 // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 2055 if (!CGF.ContainsLabel(E->getRHS())) 2056 return llvm::Constant::getNullValue(ResTy); 2057 } 2058 2059 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 2060 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 2061 2062 // Branch on the LHS first. If it is false, go to the failure (cont) block. 2063 CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 2064 2065 // Any edges into the ContBlock are now from an (indeterminate number of) 2066 // edges from this first condition. All of these values will be false. Start 2067 // setting up the PHI node in the Cont Block for this. 2068 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2069 "", ContBlock); 2070 PN->reserveOperandSpace(2); // Normal case, two inputs. 2071 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2072 PI != PE; ++PI) 2073 PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 2074 2075 CGF.BeginConditionalBranch(); 2076 CGF.EmitBlock(RHSBlock); 2077 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2078 CGF.EndConditionalBranch(); 2079 2080 // Reaquire the RHS block, as there may be subblocks inserted. 2081 RHSBlock = Builder.GetInsertBlock(); 2082 2083 // Emit an unconditional branch from this block to ContBlock. Insert an entry 2084 // into the phi node for the edge with the value of RHSCond. 2085 CGF.EmitBlock(ContBlock); 2086 PN->addIncoming(RHSCond, RHSBlock); 2087 2088 // ZExt result to int. 2089 return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 2090} 2091 2092Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 2093 const llvm::Type *ResTy = ConvertType(E->getType()); 2094 2095 // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 2096 // If we have 0 || X, just emit X without inserting the control flow. 2097 if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 2098 if (Cond == -1) { // If we have 0 || X, just emit X. 2099 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2100 // ZExt result to int or bool. 2101 return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 2102 } 2103 2104 // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 2105 if (!CGF.ContainsLabel(E->getRHS())) 2106 return llvm::ConstantInt::get(ResTy, 1); 2107 } 2108 2109 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 2110 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 2111 2112 // Branch on the LHS first. If it is true, go to the success (cont) block. 2113 CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 2114 2115 // Any edges into the ContBlock are now from an (indeterminate number of) 2116 // edges from this first condition. All of these values will be true. Start 2117 // setting up the PHI node in the Cont Block for this. 2118 llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2119 "", ContBlock); 2120 PN->reserveOperandSpace(2); // Normal case, two inputs. 2121 for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2122 PI != PE; ++PI) 2123 PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 2124 2125 CGF.BeginConditionalBranch(); 2126 2127 // Emit the RHS condition as a bool value. 2128 CGF.EmitBlock(RHSBlock); 2129 Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2130 2131 CGF.EndConditionalBranch(); 2132 2133 // Reaquire the RHS block, as there may be subblocks inserted. 2134 RHSBlock = Builder.GetInsertBlock(); 2135 2136 // Emit an unconditional branch from this block to ContBlock. Insert an entry 2137 // into the phi node for the edge with the value of RHSCond. 2138 CGF.EmitBlock(ContBlock); 2139 PN->addIncoming(RHSCond, RHSBlock); 2140 2141 // ZExt result to int. 2142 return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 2143} 2144 2145Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 2146 CGF.EmitStmt(E->getLHS()); 2147 CGF.EnsureInsertPoint(); 2148 return Visit(E->getRHS()); 2149} 2150 2151//===----------------------------------------------------------------------===// 2152// Other Operators 2153//===----------------------------------------------------------------------===// 2154 2155/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 2156/// expression is cheap enough and side-effect-free enough to evaluate 2157/// unconditionally instead of conditionally. This is used to convert control 2158/// flow into selects in some cases. 2159static bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 2160 CodeGenFunction &CGF) { 2161 if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) 2162 return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr(), CGF); 2163 2164 // TODO: Allow anything we can constant fold to an integer or fp constant. 2165 if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) || 2166 isa<FloatingLiteral>(E)) 2167 return true; 2168 2169 // Non-volatile automatic variables too, to get "cond ? X : Y" where 2170 // X and Y are local variables. 2171 if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 2172 if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 2173 if (VD->hasLocalStorage() && !(CGF.getContext() 2174 .getCanonicalType(VD->getType()) 2175 .isVolatileQualified())) 2176 return true; 2177 2178 return false; 2179} 2180 2181 2182Value *ScalarExprEmitter:: 2183VisitConditionalOperator(const ConditionalOperator *E) { 2184 TestAndClearIgnoreResultAssign(); 2185 // If the condition constant folds and can be elided, try to avoid emitting 2186 // the condition and the dead arm. 2187 if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getCond())){ 2188 Expr *Live = E->getLHS(), *Dead = E->getRHS(); 2189 if (Cond == -1) 2190 std::swap(Live, Dead); 2191 2192 // If the dead side doesn't have labels we need, and if the Live side isn't 2193 // the gnu missing ?: extension (which we could handle, but don't bother 2194 // to), just emit the Live part. 2195 if ((!Dead || !CGF.ContainsLabel(Dead)) && // No labels in dead part 2196 Live) // Live part isn't missing. 2197 return Visit(Live); 2198 } 2199 2200 // OpenCL: If the condition is a vector, we can treat this condition like 2201 // the select function. 2202 if (CGF.getContext().getLangOptions().OpenCL 2203 && E->getCond()->getType()->isVectorType()) { 2204 llvm::Value *CondV = CGF.EmitScalarExpr(E->getCond()); 2205 llvm::Value *LHS = Visit(E->getLHS()); 2206 llvm::Value *RHS = Visit(E->getRHS()); 2207 2208 const llvm::Type *condType = ConvertType(E->getCond()->getType()); 2209 const llvm::VectorType *vecTy = cast<llvm::VectorType>(condType); 2210 2211 unsigned numElem = vecTy->getNumElements(); 2212 const llvm::Type *elemType = vecTy->getElementType(); 2213 2214 std::vector<llvm::Constant*> Zvals; 2215 for (unsigned i = 0; i < numElem; ++i) 2216 Zvals.push_back(llvm::ConstantInt::get(elemType,0)); 2217 2218 llvm::Value *zeroVec = llvm::ConstantVector::get(Zvals); 2219 llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec); 2220 llvm::Value *tmp = Builder.CreateSExt(TestMSB, 2221 llvm::VectorType::get(elemType, 2222 numElem), 2223 "sext"); 2224 llvm::Value *tmp2 = Builder.CreateNot(tmp); 2225 2226 // Cast float to int to perform ANDs if necessary. 2227 llvm::Value *RHSTmp = RHS; 2228 llvm::Value *LHSTmp = LHS; 2229 bool wasCast = false; 2230 const llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType()); 2231 if (rhsVTy->getElementType()->isFloatTy()) { 2232 RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType()); 2233 LHSTmp = Builder.CreateBitCast(LHS, tmp->getType()); 2234 wasCast = true; 2235 } 2236 2237 llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2); 2238 llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp); 2239 llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond"); 2240 if (wasCast) 2241 tmp5 = Builder.CreateBitCast(tmp5, RHS->getType()); 2242 2243 return tmp5; 2244 } 2245 2246 // If this is a really simple expression (like x ? 4 : 5), emit this as a 2247 // select instead of as control flow. We can only do this if it is cheap and 2248 // safe to evaluate the LHS and RHS unconditionally. 2249 if (E->getLHS() && isCheapEnoughToEvaluateUnconditionally(E->getLHS(), 2250 CGF) && 2251 isCheapEnoughToEvaluateUnconditionally(E->getRHS(), CGF)) { 2252 llvm::Value *CondV = CGF.EvaluateExprAsBool(E->getCond()); 2253 llvm::Value *LHS = Visit(E->getLHS()); 2254 llvm::Value *RHS = Visit(E->getRHS()); 2255 return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 2256 } 2257 2258 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 2259 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 2260 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 2261 2262 // If we don't have the GNU missing condition extension, emit a branch on bool 2263 // the normal way. 2264 if (E->getLHS()) { 2265 // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for 2266 // the branch on bool. 2267 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 2268 } else { 2269 // Otherwise, for the ?: extension, evaluate the conditional and then 2270 // convert it to bool the hard way. We do this explicitly because we need 2271 // the unconverted value for the missing middle value of the ?:. 2272 Expr *save = E->getSAVE(); 2273 assert(save && "VisitConditionalOperator - save is null"); 2274 // Intentianlly not doing direct assignment to ConditionalSaveExprs[save] !! 2275 Value *SaveVal = CGF.EmitScalarExpr(save); 2276 CGF.ConditionalSaveExprs[save] = SaveVal; 2277 Value *CondVal = Visit(E->getCond()); 2278 // In some cases, EmitScalarConversion will delete the "CondVal" expression 2279 // if there are no extra uses (an optimization). Inhibit this by making an 2280 // extra dead use, because we're going to add a use of CondVal later. We 2281 // don't use the builder for this, because we don't want it to get optimized 2282 // away. This leaves dead code, but the ?: extension isn't common. 2283 new llvm::BitCastInst(CondVal, CondVal->getType(), "dummy?:holder", 2284 Builder.GetInsertBlock()); 2285 2286 Value *CondBoolVal = 2287 CGF.EmitScalarConversion(CondVal, E->getCond()->getType(), 2288 CGF.getContext().BoolTy); 2289 Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock); 2290 } 2291 2292 CGF.BeginConditionalBranch(); 2293 CGF.EmitBlock(LHSBlock); 2294 2295 // Handle the GNU extension for missing LHS. 2296 Value *LHS = Visit(E->getTrueExpr()); 2297 2298 CGF.EndConditionalBranch(); 2299 LHSBlock = Builder.GetInsertBlock(); 2300 CGF.EmitBranch(ContBlock); 2301 2302 CGF.BeginConditionalBranch(); 2303 CGF.EmitBlock(RHSBlock); 2304 2305 Value *RHS = Visit(E->getRHS()); 2306 CGF.EndConditionalBranch(); 2307 RHSBlock = Builder.GetInsertBlock(); 2308 CGF.EmitBranch(ContBlock); 2309 2310 CGF.EmitBlock(ContBlock); 2311 2312 // If the LHS or RHS is a throw expression, it will be legitimately null. 2313 if (!LHS) 2314 return RHS; 2315 if (!RHS) 2316 return LHS; 2317 2318 // Create a PHI node for the real part. 2319 llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond"); 2320 PN->reserveOperandSpace(2); 2321 PN->addIncoming(LHS, LHSBlock); 2322 PN->addIncoming(RHS, RHSBlock); 2323 return PN; 2324} 2325 2326Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 2327 return Visit(E->getChosenSubExpr(CGF.getContext())); 2328} 2329 2330Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 2331 llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 2332 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 2333 2334 // If EmitVAArg fails, we fall back to the LLVM instruction. 2335 if (!ArgPtr) 2336 return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 2337 2338 // FIXME Volatility. 2339 return Builder.CreateLoad(ArgPtr); 2340} 2341 2342Value *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *BE) { 2343 return CGF.BuildBlockLiteralTmp(BE); 2344} 2345 2346//===----------------------------------------------------------------------===// 2347// Entry Point into this File 2348//===----------------------------------------------------------------------===// 2349 2350/// EmitScalarExpr - Emit the computation of the specified expression of scalar 2351/// type, ignoring the result. 2352Value *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 2353 assert(E && !hasAggregateLLVMType(E->getType()) && 2354 "Invalid scalar expression to emit"); 2355 2356 return ScalarExprEmitter(*this, IgnoreResultAssign) 2357 .Visit(const_cast<Expr*>(E)); 2358} 2359 2360/// EmitScalarConversion - Emit a conversion from the specified type to the 2361/// specified destination type, both of which are LLVM scalar types. 2362Value *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 2363 QualType DstTy) { 2364 assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 2365 "Invalid scalar expression to emit"); 2366 return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 2367} 2368 2369/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 2370/// type to the specified destination type, where the destination type is an 2371/// LLVM scalar type. 2372Value *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 2373 QualType SrcTy, 2374 QualType DstTy) { 2375 assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 2376 "Invalid complex -> scalar conversion"); 2377 return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 2378 DstTy); 2379} 2380 2381 2382llvm::Value *CodeGenFunction:: 2383EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 2384 bool isInc, bool isPre) { 2385 return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre); 2386} 2387 2388LValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 2389 llvm::Value *V; 2390 // object->isa or (*object).isa 2391 // Generate code as for: *(Class*)object 2392 // build Class* type 2393 const llvm::Type *ClassPtrTy = ConvertType(E->getType()); 2394 2395 Expr *BaseExpr = E->getBase(); 2396 if (BaseExpr->isLvalue(getContext()) != Expr::LV_Valid) { 2397 V = CreateTempAlloca(ClassPtrTy, "resval"); 2398 llvm::Value *Src = EmitScalarExpr(BaseExpr); 2399 Builder.CreateStore(Src, V); 2400 V = ScalarExprEmitter(*this).EmitLoadOfLValue( 2401 MakeAddrLValue(V, E->getType()), E->getType()); 2402 } else { 2403 if (E->isArrow()) 2404 V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr); 2405 else 2406 V = EmitLValue(BaseExpr).getAddress(); 2407 } 2408 2409 // build Class* type 2410 ClassPtrTy = ClassPtrTy->getPointerTo(); 2411 V = Builder.CreateBitCast(V, ClassPtrTy); 2412 return MakeAddrLValue(V, E->getType()); 2413} 2414 2415 2416LValue CodeGenFunction::EmitCompoundAssignOperatorLValue( 2417 const CompoundAssignOperator *E) { 2418 ScalarExprEmitter Scalar(*this); 2419 Value *Result = 0; 2420 switch (E->getOpcode()) { 2421#define COMPOUND_OP(Op) \ 2422 case BO_##Op##Assign: \ 2423 return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 2424 Result) 2425 COMPOUND_OP(Mul); 2426 COMPOUND_OP(Div); 2427 COMPOUND_OP(Rem); 2428 COMPOUND_OP(Add); 2429 COMPOUND_OP(Sub); 2430 COMPOUND_OP(Shl); 2431 COMPOUND_OP(Shr); 2432 COMPOUND_OP(And); 2433 COMPOUND_OP(Xor); 2434 COMPOUND_OP(Or); 2435#undef COMPOUND_OP 2436 2437 case BO_PtrMemD: 2438 case BO_PtrMemI: 2439 case BO_Mul: 2440 case BO_Div: 2441 case BO_Rem: 2442 case BO_Add: 2443 case BO_Sub: 2444 case BO_Shl: 2445 case BO_Shr: 2446 case BO_LT: 2447 case BO_GT: 2448 case BO_LE: 2449 case BO_GE: 2450 case BO_EQ: 2451 case BO_NE: 2452 case BO_And: 2453 case BO_Xor: 2454 case BO_Or: 2455 case BO_LAnd: 2456 case BO_LOr: 2457 case BO_Assign: 2458 case BO_Comma: 2459 assert(false && "Not valid compound assignment operators"); 2460 break; 2461 } 2462 2463 llvm_unreachable("Unhandled compound assignment operator"); 2464} 2465