CGExprScalar.cpp revision 212904
1193326Sed//===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===// 2193326Sed// 3193326Sed// The LLVM Compiler Infrastructure 4193326Sed// 5193326Sed// This file is distributed under the University of Illinois Open Source 6193326Sed// License. See LICENSE.TXT for details. 7193326Sed// 8193326Sed//===----------------------------------------------------------------------===// 9193326Sed// 10193326Sed// This contains code to emit Expr nodes with scalar LLVM types as LLVM code. 11193326Sed// 12193326Sed//===----------------------------------------------------------------------===// 13193326Sed 14193326Sed#include "CodeGenFunction.h" 15212904Sdim#include "CGCXXABI.h" 16198092Srdivacky#include "CGObjCRuntime.h" 17193326Sed#include "CodeGenModule.h" 18193326Sed#include "clang/AST/ASTContext.h" 19193326Sed#include "clang/AST/DeclObjC.h" 20193326Sed#include "clang/AST/RecordLayout.h" 21193326Sed#include "clang/AST/StmtVisitor.h" 22193326Sed#include "clang/Basic/TargetInfo.h" 23193326Sed#include "llvm/Constants.h" 24193326Sed#include "llvm/Function.h" 25193326Sed#include "llvm/GlobalVariable.h" 26193326Sed#include "llvm/Intrinsics.h" 27193326Sed#include "llvm/Module.h" 28193326Sed#include "llvm/Support/CFG.h" 29193326Sed#include "llvm/Target/TargetData.h" 30193326Sed#include <cstdarg> 31193326Sed 32193326Sedusing namespace clang; 33193326Sedusing namespace CodeGen; 34193326Sedusing llvm::Value; 35193326Sed 36193326Sed//===----------------------------------------------------------------------===// 37193326Sed// Scalar Expression Emitter 38193326Sed//===----------------------------------------------------------------------===// 39193326Sed 40193326Sedstruct BinOpInfo { 41193326Sed Value *LHS; 42193326Sed Value *RHS; 43193326Sed QualType Ty; // Computation Type. 44210299Sed BinaryOperator::Opcode Opcode; // Opcode of BinOp to perform 45210299Sed const Expr *E; // Entire expr, for error unsupported. May not be binop. 46193326Sed}; 47193326Sed 48193326Sednamespace { 49199990Srdivackyclass ScalarExprEmitter 50193326Sed : public StmtVisitor<ScalarExprEmitter, Value*> { 51193326Sed CodeGenFunction &CGF; 52193326Sed CGBuilderTy &Builder; 53193326Sed bool IgnoreResultAssign; 54198092Srdivacky llvm::LLVMContext &VMContext; 55193326Sedpublic: 56193326Sed 57193326Sed ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false) 58198092Srdivacky : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira), 59198092Srdivacky VMContext(cgf.getLLVMContext()) { 60193326Sed } 61198092Srdivacky 62193326Sed //===--------------------------------------------------------------------===// 63193326Sed // Utilities 64193326Sed //===--------------------------------------------------------------------===// 65193326Sed 66193326Sed bool TestAndClearIgnoreResultAssign() { 67198092Srdivacky bool I = IgnoreResultAssign; 68198092Srdivacky IgnoreResultAssign = false; 69198092Srdivacky return I; 70198092Srdivacky } 71193326Sed 72193326Sed const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); } 73193326Sed LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); } 74201361Srdivacky LValue EmitCheckedLValue(const Expr *E) { return CGF.EmitCheckedLValue(E); } 75193326Sed 76193326Sed Value *EmitLoadOfLValue(LValue LV, QualType T) { 77193326Sed return CGF.EmitLoadOfLValue(LV, T).getScalarVal(); 78193326Sed } 79198092Srdivacky 80193326Sed /// EmitLoadOfLValue - Given an expression with complex type that represents a 81193326Sed /// value l-value, this method emits the address of the l-value, then loads 82193326Sed /// and returns the result. 83193326Sed Value *EmitLoadOfLValue(const Expr *E) { 84201361Srdivacky return EmitLoadOfLValue(EmitCheckedLValue(E), E->getType()); 85193326Sed } 86198092Srdivacky 87193326Sed /// EmitConversionToBool - Convert the specified expression value to a 88193326Sed /// boolean (i1) truth value. This is equivalent to "Val != 0". 89193326Sed Value *EmitConversionToBool(Value *Src, QualType DstTy); 90198092Srdivacky 91193326Sed /// EmitScalarConversion - Emit a conversion from the specified type to the 92193326Sed /// specified destination type, both of which are LLVM scalar types. 93193326Sed Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy); 94193326Sed 95193326Sed /// EmitComplexToScalarConversion - Emit a conversion from the specified 96198092Srdivacky /// complex type to the specified destination type, where the destination type 97198092Srdivacky /// is an LLVM scalar type. 98193326Sed Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 99193326Sed QualType SrcTy, QualType DstTy); 100193326Sed 101208600Srdivacky /// EmitNullValue - Emit a value that corresponds to null for the given type. 102208600Srdivacky Value *EmitNullValue(QualType Ty); 103208600Srdivacky 104193326Sed //===--------------------------------------------------------------------===// 105193326Sed // Visitor Methods 106193326Sed //===--------------------------------------------------------------------===// 107193326Sed 108193326Sed Value *VisitStmt(Stmt *S) { 109193326Sed S->dump(CGF.getContext().getSourceManager()); 110193326Sed assert(0 && "Stmt can't have complex result type!"); 111193326Sed return 0; 112193326Sed } 113193326Sed Value *VisitExpr(Expr *S); 114198398Srdivacky 115193326Sed Value *VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr()); } 116193326Sed 117193326Sed // Leaves. 118193326Sed Value *VisitIntegerLiteral(const IntegerLiteral *E) { 119198092Srdivacky return llvm::ConstantInt::get(VMContext, E->getValue()); 120193326Sed } 121193326Sed Value *VisitFloatingLiteral(const FloatingLiteral *E) { 122198092Srdivacky return llvm::ConstantFP::get(VMContext, E->getValue()); 123193326Sed } 124193326Sed Value *VisitCharacterLiteral(const CharacterLiteral *E) { 125193326Sed return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 126193326Sed } 127193326Sed Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 128193326Sed return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 129193326Sed } 130210299Sed Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) { 131208600Srdivacky return EmitNullValue(E->getType()); 132193326Sed } 133193326Sed Value *VisitGNUNullExpr(const GNUNullExpr *E) { 134208600Srdivacky return EmitNullValue(E->getType()); 135193326Sed } 136193326Sed Value *VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) { 137193326Sed return llvm::ConstantInt::get(ConvertType(E->getType()), 138193326Sed CGF.getContext().typesAreCompatible( 139193326Sed E->getArgType1(), E->getArgType2())); 140193326Sed } 141212904Sdim Value *VisitOffsetOfExpr(OffsetOfExpr *E); 142193326Sed Value *VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E); 143193326Sed Value *VisitAddrLabelExpr(const AddrLabelExpr *E) { 144198893Srdivacky llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel()); 145198893Srdivacky return Builder.CreateBitCast(V, ConvertType(E->getType())); 146193326Sed } 147198092Srdivacky 148193326Sed // l-values. 149193326Sed Value *VisitDeclRefExpr(DeclRefExpr *E) { 150199990Srdivacky Expr::EvalResult Result; 151199990Srdivacky if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 152199990Srdivacky assert(!Result.HasSideEffects && "Constant declref with side-effect?!"); 153212904Sdim llvm::ConstantInt *CI 154212904Sdim = llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 155212904Sdim CGF.EmitDeclRefExprDbgValue(E, CI); 156212904Sdim return CI; 157199990Srdivacky } 158193326Sed return EmitLoadOfLValue(E); 159193326Sed } 160198092Srdivacky Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 161198092Srdivacky return CGF.EmitObjCSelectorExpr(E); 162193326Sed } 163198092Srdivacky Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 164198092Srdivacky return CGF.EmitObjCProtocolExpr(E); 165193326Sed } 166198092Srdivacky Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 167193326Sed return EmitLoadOfLValue(E); 168193326Sed } 169193326Sed Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 170193326Sed return EmitLoadOfLValue(E); 171193326Sed } 172198092Srdivacky Value *VisitObjCImplicitSetterGetterRefExpr( 173198092Srdivacky ObjCImplicitSetterGetterRefExpr *E) { 174193326Sed return EmitLoadOfLValue(E); 175193326Sed } 176193326Sed Value *VisitObjCMessageExpr(ObjCMessageExpr *E) { 177193326Sed return CGF.EmitObjCMessageExpr(E).getScalarVal(); 178193326Sed } 179193326Sed 180200583Srdivacky Value *VisitObjCIsaExpr(ObjCIsaExpr *E) { 181200583Srdivacky LValue LV = CGF.EmitObjCIsaExpr(E); 182200583Srdivacky Value *V = CGF.EmitLoadOfLValue(LV, E->getType()).getScalarVal(); 183200583Srdivacky return V; 184200583Srdivacky } 185200583Srdivacky 186193326Sed Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 187193326Sed Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E); 188199990Srdivacky Value *VisitMemberExpr(MemberExpr *E); 189193326Sed Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); } 190193326Sed Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 191193326Sed return EmitLoadOfLValue(E); 192193326Sed } 193198092Srdivacky 194198398Srdivacky Value *VisitInitListExpr(InitListExpr *E); 195198092Srdivacky 196193326Sed Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) { 197208600Srdivacky return CGF.CGM.EmitNullConstant(E->getType()); 198193326Sed } 199199990Srdivacky Value *VisitCastExpr(CastExpr *E) { 200193326Sed // Make sure to evaluate VLA bounds now so that we have them for later. 201193326Sed if (E->getType()->isVariablyModifiedType()) 202193326Sed CGF.EmitVLASize(E->getType()); 203193326Sed 204198092Srdivacky return EmitCastExpr(E); 205193326Sed } 206199990Srdivacky Value *EmitCastExpr(CastExpr *E); 207193326Sed 208193326Sed Value *VisitCallExpr(const CallExpr *E) { 209193326Sed if (E->getCallReturnType()->isReferenceType()) 210193326Sed return EmitLoadOfLValue(E); 211198092Srdivacky 212193326Sed return CGF.EmitCallExpr(E).getScalarVal(); 213193326Sed } 214193326Sed 215193326Sed Value *VisitStmtExpr(const StmtExpr *E); 216193326Sed 217193326Sed Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E); 218198092Srdivacky 219193326Sed // Unary Operators. 220210299Sed Value *VisitUnaryPostDec(const UnaryOperator *E) { 221202379Srdivacky LValue LV = EmitLValue(E->getSubExpr()); 222210299Sed return EmitScalarPrePostIncDec(E, LV, false, false); 223202379Srdivacky } 224193326Sed Value *VisitUnaryPostInc(const UnaryOperator *E) { 225210299Sed LValue LV = EmitLValue(E->getSubExpr()); 226210299Sed return EmitScalarPrePostIncDec(E, LV, true, false); 227193326Sed } 228193326Sed Value *VisitUnaryPreDec(const UnaryOperator *E) { 229210299Sed LValue LV = EmitLValue(E->getSubExpr()); 230210299Sed return EmitScalarPrePostIncDec(E, LV, false, true); 231193326Sed } 232193326Sed Value *VisitUnaryPreInc(const UnaryOperator *E) { 233210299Sed LValue LV = EmitLValue(E->getSubExpr()); 234210299Sed return EmitScalarPrePostIncDec(E, LV, true, true); 235193326Sed } 236210299Sed 237210299Sed llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 238210299Sed bool isInc, bool isPre); 239210299Sed 240210299Sed 241193326Sed Value *VisitUnaryAddrOf(const UnaryOperator *E) { 242212904Sdim // If the sub-expression is an instance member reference, 243212904Sdim // EmitDeclRefLValue will magically emit it with the appropriate 244212904Sdim // value as the "address". 245193326Sed return EmitLValue(E->getSubExpr()).getAddress(); 246193326Sed } 247193326Sed Value *VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 248193326Sed Value *VisitUnaryPlus(const UnaryOperator *E) { 249193326Sed // This differs from gcc, though, most likely due to a bug in gcc. 250193326Sed TestAndClearIgnoreResultAssign(); 251193326Sed return Visit(E->getSubExpr()); 252193326Sed } 253193326Sed Value *VisitUnaryMinus (const UnaryOperator *E); 254193326Sed Value *VisitUnaryNot (const UnaryOperator *E); 255193326Sed Value *VisitUnaryLNot (const UnaryOperator *E); 256193326Sed Value *VisitUnaryReal (const UnaryOperator *E); 257193326Sed Value *VisitUnaryImag (const UnaryOperator *E); 258193326Sed Value *VisitUnaryExtension(const UnaryOperator *E) { 259193326Sed return Visit(E->getSubExpr()); 260193326Sed } 261207619Srdivacky 262193326Sed // C++ 263193326Sed Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 264193326Sed return Visit(DAE->getExpr()); 265193326Sed } 266193326Sed Value *VisitCXXThisExpr(CXXThisExpr *TE) { 267193326Sed return CGF.LoadCXXThis(); 268198092Srdivacky } 269198092Srdivacky 270193326Sed Value *VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { 271193326Sed return CGF.EmitCXXExprWithTemporaries(E).getScalarVal(); 272193326Sed } 273193326Sed Value *VisitCXXNewExpr(const CXXNewExpr *E) { 274193326Sed return CGF.EmitCXXNewExpr(E); 275193326Sed } 276198092Srdivacky Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) { 277198092Srdivacky CGF.EmitCXXDeleteExpr(E); 278198092Srdivacky return 0; 279198092Srdivacky } 280200583Srdivacky Value *VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 281200583Srdivacky return llvm::ConstantInt::get(Builder.getInt1Ty(), 282200583Srdivacky E->EvaluateTrait(CGF.getContext())); 283200583Srdivacky } 284198092Srdivacky 285198092Srdivacky Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) { 286198092Srdivacky // C++ [expr.pseudo]p1: 287198092Srdivacky // The result shall only be used as the operand for the function call 288198092Srdivacky // operator (), and the result of such a call has type void. The only 289198092Srdivacky // effect is the evaluation of the postfix-expression before the dot or 290198092Srdivacky // arrow. 291198092Srdivacky CGF.EmitScalarExpr(E->getBase()); 292198092Srdivacky return 0; 293198092Srdivacky } 294198092Srdivacky 295198092Srdivacky Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 296208600Srdivacky return EmitNullValue(E->getType()); 297198092Srdivacky } 298198893Srdivacky 299198893Srdivacky Value *VisitCXXThrowExpr(const CXXThrowExpr *E) { 300198893Srdivacky CGF.EmitCXXThrowExpr(E); 301198893Srdivacky return 0; 302198893Srdivacky } 303198893Srdivacky 304193326Sed // Binary Operators. 305193326Sed Value *EmitMul(const BinOpInfo &Ops) { 306212904Sdim if (Ops.Ty->hasSignedIntegerRepresentation()) { 307210299Sed switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 308210299Sed case LangOptions::SOB_Undefined: 309210299Sed return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul"); 310210299Sed case LangOptions::SOB_Defined: 311210299Sed return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 312210299Sed case LangOptions::SOB_Trapping: 313210299Sed return EmitOverflowCheckedBinOp(Ops); 314210299Sed } 315210299Sed } 316210299Sed 317203955Srdivacky if (Ops.LHS->getType()->isFPOrFPVectorTy()) 318194613Sed return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul"); 319193326Sed return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 320193326Sed } 321193326Sed /// Create a binary op that checks for overflow. 322193326Sed /// Currently only supports +, - and *. 323193326Sed Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); 324193326Sed Value *EmitDiv(const BinOpInfo &Ops); 325193326Sed Value *EmitRem(const BinOpInfo &Ops); 326193326Sed Value *EmitAdd(const BinOpInfo &Ops); 327193326Sed Value *EmitSub(const BinOpInfo &Ops); 328193326Sed Value *EmitShl(const BinOpInfo &Ops); 329193326Sed Value *EmitShr(const BinOpInfo &Ops); 330193326Sed Value *EmitAnd(const BinOpInfo &Ops) { 331193326Sed return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 332193326Sed } 333193326Sed Value *EmitXor(const BinOpInfo &Ops) { 334193326Sed return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 335193326Sed } 336193326Sed Value *EmitOr (const BinOpInfo &Ops) { 337193326Sed return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 338193326Sed } 339193326Sed 340193326Sed BinOpInfo EmitBinOps(const BinaryOperator *E); 341207619Srdivacky LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 342207619Srdivacky Value *(ScalarExprEmitter::*F)(const BinOpInfo &), 343210299Sed Value *&Result); 344207619Srdivacky 345193326Sed Value *EmitCompoundAssign(const CompoundAssignOperator *E, 346193326Sed Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 347193326Sed 348193326Sed // Binary operators and binary compound assignment operators. 349193326Sed#define HANDLEBINOP(OP) \ 350193326Sed Value *VisitBin ## OP(const BinaryOperator *E) { \ 351193326Sed return Emit ## OP(EmitBinOps(E)); \ 352193326Sed } \ 353193326Sed Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 354193326Sed return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 355193326Sed } 356201361Srdivacky HANDLEBINOP(Mul) 357201361Srdivacky HANDLEBINOP(Div) 358201361Srdivacky HANDLEBINOP(Rem) 359201361Srdivacky HANDLEBINOP(Add) 360201361Srdivacky HANDLEBINOP(Sub) 361201361Srdivacky HANDLEBINOP(Shl) 362201361Srdivacky HANDLEBINOP(Shr) 363201361Srdivacky HANDLEBINOP(And) 364201361Srdivacky HANDLEBINOP(Xor) 365201361Srdivacky HANDLEBINOP(Or) 366193326Sed#undef HANDLEBINOP 367193326Sed 368193326Sed // Comparisons. 369193326Sed Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 370193326Sed unsigned SICmpOpc, unsigned FCmpOpc); 371193326Sed#define VISITCOMP(CODE, UI, SI, FP) \ 372193326Sed Value *VisitBin##CODE(const BinaryOperator *E) { \ 373193326Sed return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 374193326Sed llvm::FCmpInst::FP); } 375201361Srdivacky VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT) 376201361Srdivacky VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT) 377201361Srdivacky VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE) 378201361Srdivacky VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE) 379201361Srdivacky VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ) 380201361Srdivacky VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE) 381193326Sed#undef VISITCOMP 382198092Srdivacky 383193326Sed Value *VisitBinAssign (const BinaryOperator *E); 384193326Sed 385193326Sed Value *VisitBinLAnd (const BinaryOperator *E); 386193326Sed Value *VisitBinLOr (const BinaryOperator *E); 387193326Sed Value *VisitBinComma (const BinaryOperator *E); 388193326Sed 389199482Srdivacky Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); } 390199482Srdivacky Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); } 391199482Srdivacky 392193326Sed // Other Operators. 393193326Sed Value *VisitBlockExpr(const BlockExpr *BE); 394193326Sed Value *VisitConditionalOperator(const ConditionalOperator *CO); 395193326Sed Value *VisitChooseExpr(ChooseExpr *CE); 396193326Sed Value *VisitVAArgExpr(VAArgExpr *VE); 397193326Sed Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 398193326Sed return CGF.EmitObjCStringLiteral(E); 399193326Sed } 400193326Sed}; 401193326Sed} // end anonymous namespace. 402193326Sed 403193326Sed//===----------------------------------------------------------------------===// 404193326Sed// Utilities 405193326Sed//===----------------------------------------------------------------------===// 406193326Sed 407193326Sed/// EmitConversionToBool - Convert the specified expression value to a 408193326Sed/// boolean (i1) truth value. This is equivalent to "Val != 0". 409193326SedValue *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 410198398Srdivacky assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs"); 411198092Srdivacky 412193326Sed if (SrcType->isRealFloatingType()) { 413193326Sed // Compare against 0.0 for fp scalars. 414193326Sed llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 415193326Sed return Builder.CreateFCmpUNE(Src, Zero, "tobool"); 416193326Sed } 417198092Srdivacky 418212904Sdim if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType)) 419212904Sdim return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT); 420198092Srdivacky 421193326Sed assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 422193326Sed "Unknown scalar type to convert"); 423198092Srdivacky 424193326Sed // Because of the type rules of C, we often end up computing a logical value, 425193326Sed // then zero extending it to int, then wanting it as a logical value again. 426193326Sed // Optimize this common case. 427193326Sed if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(Src)) { 428198092Srdivacky if (ZI->getOperand(0)->getType() == 429198092Srdivacky llvm::Type::getInt1Ty(CGF.getLLVMContext())) { 430193326Sed Value *Result = ZI->getOperand(0); 431193326Sed // If there aren't any more uses, zap the instruction to save space. 432193326Sed // Note that there can be more uses, for example if this 433193326Sed // is the result of an assignment. 434193326Sed if (ZI->use_empty()) 435193326Sed ZI->eraseFromParent(); 436193326Sed return Result; 437193326Sed } 438193326Sed } 439198092Srdivacky 440193326Sed // Compare against an integer or pointer null. 441193326Sed llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 442193326Sed return Builder.CreateICmpNE(Src, Zero, "tobool"); 443193326Sed} 444193326Sed 445193326Sed/// EmitScalarConversion - Emit a conversion from the specified type to the 446193326Sed/// specified destination type, both of which are LLVM scalar types. 447193326SedValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 448193326Sed QualType DstType) { 449193326Sed SrcType = CGF.getContext().getCanonicalType(SrcType); 450193326Sed DstType = CGF.getContext().getCanonicalType(DstType); 451193326Sed if (SrcType == DstType) return Src; 452198092Srdivacky 453193326Sed if (DstType->isVoidType()) return 0; 454193326Sed 455193326Sed // Handle conversions to bool first, they are special: comparisons against 0. 456193326Sed if (DstType->isBooleanType()) 457193326Sed return EmitConversionToBool(Src, SrcType); 458198092Srdivacky 459193326Sed const llvm::Type *DstTy = ConvertType(DstType); 460193326Sed 461193326Sed // Ignore conversions like int -> uint. 462193326Sed if (Src->getType() == DstTy) 463193326Sed return Src; 464193326Sed 465198092Srdivacky // Handle pointer conversions next: pointers can only be converted to/from 466198092Srdivacky // other pointers and integers. Check for pointer types in terms of LLVM, as 467198092Srdivacky // some native types (like Obj-C id) may map to a pointer type. 468193326Sed if (isa<llvm::PointerType>(DstTy)) { 469193326Sed // The source value may be an integer, or a pointer. 470193326Sed if (isa<llvm::PointerType>(Src->getType())) 471193326Sed return Builder.CreateBitCast(Src, DstTy, "conv"); 472198092Srdivacky 473193326Sed assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 474193326Sed // First, convert to the correct width so that we control the kind of 475193326Sed // extension. 476210299Sed const llvm::Type *MiddleTy = CGF.IntPtrTy; 477193326Sed bool InputSigned = SrcType->isSignedIntegerType(); 478193326Sed llvm::Value* IntResult = 479193326Sed Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 480193326Sed // Then, cast to pointer. 481193326Sed return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 482193326Sed } 483198092Srdivacky 484193326Sed if (isa<llvm::PointerType>(Src->getType())) { 485193326Sed // Must be an ptr to int cast. 486193326Sed assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 487193326Sed return Builder.CreatePtrToInt(Src, DstTy, "conv"); 488193326Sed } 489198092Srdivacky 490193326Sed // A scalar can be splatted to an extended vector of the same element type 491198092Srdivacky if (DstType->isExtVectorType() && !SrcType->isVectorType()) { 492193326Sed // Cast the scalar to element type 493198092Srdivacky QualType EltTy = DstType->getAs<ExtVectorType>()->getElementType(); 494193326Sed llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 495193326Sed 496193326Sed // Insert the element in element zero of an undef vector 497193326Sed llvm::Value *UnV = llvm::UndefValue::get(DstTy); 498210299Sed llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 499193326Sed UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 500193326Sed 501193326Sed // Splat the element across to all elements 502193326Sed llvm::SmallVector<llvm::Constant*, 16> Args; 503193326Sed unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 504193326Sed for (unsigned i = 0; i < NumElements; i++) 505210299Sed Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 0)); 506198092Srdivacky 507193326Sed llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 508193326Sed llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 509193326Sed return Yay; 510193326Sed } 511193326Sed 512193326Sed // Allow bitcast from vector to integer/fp of the same size. 513193326Sed if (isa<llvm::VectorType>(Src->getType()) || 514193326Sed isa<llvm::VectorType>(DstTy)) 515193326Sed return Builder.CreateBitCast(Src, DstTy, "conv"); 516198092Srdivacky 517193326Sed // Finally, we have the arithmetic types: real int/float. 518193326Sed if (isa<llvm::IntegerType>(Src->getType())) { 519193326Sed bool InputSigned = SrcType->isSignedIntegerType(); 520193326Sed if (isa<llvm::IntegerType>(DstTy)) 521193326Sed return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 522193326Sed else if (InputSigned) 523193326Sed return Builder.CreateSIToFP(Src, DstTy, "conv"); 524193326Sed else 525193326Sed return Builder.CreateUIToFP(Src, DstTy, "conv"); 526193326Sed } 527198092Srdivacky 528203955Srdivacky assert(Src->getType()->isFloatingPointTy() && "Unknown real conversion"); 529193326Sed if (isa<llvm::IntegerType>(DstTy)) { 530193326Sed if (DstType->isSignedIntegerType()) 531193326Sed return Builder.CreateFPToSI(Src, DstTy, "conv"); 532193326Sed else 533193326Sed return Builder.CreateFPToUI(Src, DstTy, "conv"); 534193326Sed } 535193326Sed 536203955Srdivacky assert(DstTy->isFloatingPointTy() && "Unknown real conversion"); 537193326Sed if (DstTy->getTypeID() < Src->getType()->getTypeID()) 538193326Sed return Builder.CreateFPTrunc(Src, DstTy, "conv"); 539193326Sed else 540193326Sed return Builder.CreateFPExt(Src, DstTy, "conv"); 541193326Sed} 542193326Sed 543198092Srdivacky/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 544198092Srdivacky/// type to the specified destination type, where the destination type is an 545198092Srdivacky/// LLVM scalar type. 546193326SedValue *ScalarExprEmitter:: 547193326SedEmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 548193326Sed QualType SrcTy, QualType DstTy) { 549193326Sed // Get the source element type. 550198092Srdivacky SrcTy = SrcTy->getAs<ComplexType>()->getElementType(); 551198092Srdivacky 552193326Sed // Handle conversions to bool first, they are special: comparisons against 0. 553193326Sed if (DstTy->isBooleanType()) { 554193326Sed // Complex != 0 -> (Real != 0) | (Imag != 0) 555193326Sed Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 556193326Sed Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 557193326Sed return Builder.CreateOr(Src.first, Src.second, "tobool"); 558193326Sed } 559198092Srdivacky 560193326Sed // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 561193326Sed // the imaginary part of the complex value is discarded and the value of the 562193326Sed // real part is converted according to the conversion rules for the 563198092Srdivacky // corresponding real type. 564193326Sed return EmitScalarConversion(Src.first, SrcTy, DstTy); 565193326Sed} 566193326Sed 567208600SrdivackyValue *ScalarExprEmitter::EmitNullValue(QualType Ty) { 568212904Sdim if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) 569212904Sdim return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 570193326Sed 571212904Sdim return llvm::Constant::getNullValue(ConvertType(Ty)); 572208600Srdivacky} 573208600Srdivacky 574193326Sed//===----------------------------------------------------------------------===// 575193326Sed// Visitor Methods 576193326Sed//===----------------------------------------------------------------------===// 577193326Sed 578193326SedValue *ScalarExprEmitter::VisitExpr(Expr *E) { 579193326Sed CGF.ErrorUnsupported(E, "scalar expression"); 580193326Sed if (E->getType()->isVoidType()) 581193326Sed return 0; 582193326Sed return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 583193326Sed} 584193326Sed 585193326SedValue *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 586210299Sed // Vector Mask Case 587210299Sed if (E->getNumSubExprs() == 2 || 588210299Sed (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { 589210299Sed Value *LHS = CGF.EmitScalarExpr(E->getExpr(0)); 590210299Sed Value *RHS = CGF.EmitScalarExpr(E->getExpr(1)); 591210299Sed Value *Mask; 592210299Sed 593210299Sed const llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType()); 594210299Sed unsigned LHSElts = LTy->getNumElements(); 595210299Sed 596210299Sed if (E->getNumSubExprs() == 3) { 597210299Sed Mask = CGF.EmitScalarExpr(E->getExpr(2)); 598210299Sed 599210299Sed // Shuffle LHS & RHS into one input vector. 600210299Sed llvm::SmallVector<llvm::Constant*, 32> concat; 601210299Sed for (unsigned i = 0; i != LHSElts; ++i) { 602210299Sed concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i)); 603210299Sed concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i+1)); 604210299Sed } 605210299Sed 606210299Sed Value* CV = llvm::ConstantVector::get(concat.begin(), concat.size()); 607210299Sed LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); 608210299Sed LHSElts *= 2; 609210299Sed } else { 610210299Sed Mask = RHS; 611210299Sed } 612210299Sed 613210299Sed const llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType()); 614210299Sed llvm::Constant* EltMask; 615210299Sed 616210299Sed // Treat vec3 like vec4. 617210299Sed if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) 618210299Sed EltMask = llvm::ConstantInt::get(MTy->getElementType(), 619210299Sed (1 << llvm::Log2_32(LHSElts+2))-1); 620210299Sed else if ((LHSElts == 3) && (E->getNumSubExprs() == 2)) 621210299Sed EltMask = llvm::ConstantInt::get(MTy->getElementType(), 622210299Sed (1 << llvm::Log2_32(LHSElts+1))-1); 623210299Sed else 624210299Sed EltMask = llvm::ConstantInt::get(MTy->getElementType(), 625210299Sed (1 << llvm::Log2_32(LHSElts))-1); 626210299Sed 627210299Sed // Mask off the high bits of each shuffle index. 628210299Sed llvm::SmallVector<llvm::Constant *, 32> MaskV; 629210299Sed for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) 630210299Sed MaskV.push_back(EltMask); 631210299Sed 632210299Sed Value* MaskBits = llvm::ConstantVector::get(MaskV.begin(), MaskV.size()); 633210299Sed Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); 634210299Sed 635210299Sed // newv = undef 636210299Sed // mask = mask & maskbits 637210299Sed // for each elt 638210299Sed // n = extract mask i 639210299Sed // x = extract val n 640210299Sed // newv = insert newv, x, i 641210299Sed const llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(), 642210299Sed MTy->getNumElements()); 643210299Sed Value* NewV = llvm::UndefValue::get(RTy); 644210299Sed for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) { 645210299Sed Value *Indx = llvm::ConstantInt::get(CGF.Int32Ty, i); 646210299Sed Indx = Builder.CreateExtractElement(Mask, Indx, "shuf_idx"); 647210299Sed Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext"); 648210299Sed 649210299Sed // Handle vec3 special since the index will be off by one for the RHS. 650210299Sed if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { 651210299Sed Value *cmpIndx, *newIndx; 652210299Sed cmpIndx = Builder.CreateICmpUGT(Indx, 653210299Sed llvm::ConstantInt::get(CGF.Int32Ty, 3), 654210299Sed "cmp_shuf_idx"); 655210299Sed newIndx = Builder.CreateSub(Indx, llvm::ConstantInt::get(CGF.Int32Ty,1), 656210299Sed "shuf_idx_adj"); 657210299Sed Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx"); 658210299Sed } 659210299Sed Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt"); 660210299Sed NewV = Builder.CreateInsertElement(NewV, VExt, Indx, "shuf_ins"); 661210299Sed } 662210299Sed return NewV; 663210299Sed } 664210299Sed 665210299Sed Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 666210299Sed Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 667210299Sed 668210299Sed // Handle vec3 special since the index will be off by one for the RHS. 669193326Sed llvm::SmallVector<llvm::Constant*, 32> indices; 670193326Sed for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 671210299Sed llvm::Constant *C = cast<llvm::Constant>(CGF.EmitScalarExpr(E->getExpr(i))); 672210299Sed const llvm::VectorType *VTy = cast<llvm::VectorType>(V1->getType()); 673210299Sed if (VTy->getNumElements() == 3) { 674210299Sed if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C)) { 675210299Sed uint64_t cVal = CI->getZExtValue(); 676210299Sed if (cVal > 3) { 677210299Sed C = llvm::ConstantInt::get(C->getType(), cVal-1); 678210299Sed } 679210299Sed } 680210299Sed } 681210299Sed indices.push_back(C); 682193326Sed } 683210299Sed 684193326Sed Value* SV = llvm::ConstantVector::get(indices.begin(), indices.size()); 685193326Sed return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 686193326Sed} 687199990SrdivackyValue *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) { 688199990Srdivacky Expr::EvalResult Result; 689199990Srdivacky if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 690199990Srdivacky if (E->isArrow()) 691199990Srdivacky CGF.EmitScalarExpr(E->getBase()); 692199990Srdivacky else 693199990Srdivacky EmitLValue(E->getBase()); 694199990Srdivacky return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 695199990Srdivacky } 696199990Srdivacky return EmitLoadOfLValue(E); 697199990Srdivacky} 698193326Sed 699193326SedValue *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 700193326Sed TestAndClearIgnoreResultAssign(); 701193326Sed 702193326Sed // Emit subscript expressions in rvalue context's. For most cases, this just 703193326Sed // loads the lvalue formed by the subscript expr. However, we have to be 704193326Sed // careful, because the base of a vector subscript is occasionally an rvalue, 705193326Sed // so we can't get it as an lvalue. 706193326Sed if (!E->getBase()->getType()->isVectorType()) 707193326Sed return EmitLoadOfLValue(E); 708198092Srdivacky 709193326Sed // Handle the vector case. The base must be a vector, the index must be an 710193326Sed // integer value. 711193326Sed Value *Base = Visit(E->getBase()); 712193326Sed Value *Idx = Visit(E->getIdx()); 713193326Sed bool IdxSigned = E->getIdx()->getType()->isSignedIntegerType(); 714210299Sed Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast"); 715193326Sed return Builder.CreateExtractElement(Base, Idx, "vecext"); 716193326Sed} 717193326Sed 718198398Srdivackystatic llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, 719198398Srdivacky unsigned Off, const llvm::Type *I32Ty) { 720198398Srdivacky int MV = SVI->getMaskValue(Idx); 721198398Srdivacky if (MV == -1) 722198398Srdivacky return llvm::UndefValue::get(I32Ty); 723198398Srdivacky return llvm::ConstantInt::get(I32Ty, Off+MV); 724198398Srdivacky} 725198398Srdivacky 726198398SrdivackyValue *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { 727198398Srdivacky bool Ignore = TestAndClearIgnoreResultAssign(); 728198398Srdivacky (void)Ignore; 729198398Srdivacky assert (Ignore == false && "init list ignored"); 730198398Srdivacky unsigned NumInitElements = E->getNumInits(); 731198398Srdivacky 732198398Srdivacky if (E->hadArrayRangeDesignator()) 733198398Srdivacky CGF.ErrorUnsupported(E, "GNU array range designator extension"); 734198398Srdivacky 735198398Srdivacky const llvm::VectorType *VType = 736198398Srdivacky dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 737198398Srdivacky 738198398Srdivacky // We have a scalar in braces. Just use the first element. 739198398Srdivacky if (!VType) 740198398Srdivacky return Visit(E->getInit(0)); 741198398Srdivacky 742198398Srdivacky unsigned ResElts = VType->getNumElements(); 743198398Srdivacky 744198398Srdivacky // Loop over initializers collecting the Value for each, and remembering 745198398Srdivacky // whether the source was swizzle (ExtVectorElementExpr). This will allow 746198398Srdivacky // us to fold the shuffle for the swizzle into the shuffle for the vector 747198398Srdivacky // initializer, since LLVM optimizers generally do not want to touch 748198398Srdivacky // shuffles. 749198398Srdivacky unsigned CurIdx = 0; 750198398Srdivacky bool VIsUndefShuffle = false; 751198398Srdivacky llvm::Value *V = llvm::UndefValue::get(VType); 752198398Srdivacky for (unsigned i = 0; i != NumInitElements; ++i) { 753198398Srdivacky Expr *IE = E->getInit(i); 754198398Srdivacky Value *Init = Visit(IE); 755198398Srdivacky llvm::SmallVector<llvm::Constant*, 16> Args; 756198398Srdivacky 757198398Srdivacky const llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType()); 758198398Srdivacky 759198398Srdivacky // Handle scalar elements. If the scalar initializer is actually one 760198398Srdivacky // element of a different vector of the same width, use shuffle instead of 761198398Srdivacky // extract+insert. 762198398Srdivacky if (!VVT) { 763198398Srdivacky if (isa<ExtVectorElementExpr>(IE)) { 764198398Srdivacky llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init); 765198398Srdivacky 766198398Srdivacky if (EI->getVectorOperandType()->getNumElements() == ResElts) { 767198398Srdivacky llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand()); 768198398Srdivacky Value *LHS = 0, *RHS = 0; 769198398Srdivacky if (CurIdx == 0) { 770198398Srdivacky // insert into undef -> shuffle (src, undef) 771198398Srdivacky Args.push_back(C); 772198398Srdivacky for (unsigned j = 1; j != ResElts; ++j) 773210299Sed Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 774198398Srdivacky 775198398Srdivacky LHS = EI->getVectorOperand(); 776198398Srdivacky RHS = V; 777198398Srdivacky VIsUndefShuffle = true; 778198398Srdivacky } else if (VIsUndefShuffle) { 779198398Srdivacky // insert into undefshuffle && size match -> shuffle (v, src) 780198398Srdivacky llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V); 781198398Srdivacky for (unsigned j = 0; j != CurIdx; ++j) 782210299Sed Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty)); 783210299Sed Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 784198398Srdivacky ResElts + C->getZExtValue())); 785198398Srdivacky for (unsigned j = CurIdx + 1; j != ResElts; ++j) 786210299Sed Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 787198398Srdivacky 788198398Srdivacky LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 789198398Srdivacky RHS = EI->getVectorOperand(); 790198398Srdivacky VIsUndefShuffle = false; 791198398Srdivacky } 792198398Srdivacky if (!Args.empty()) { 793198398Srdivacky llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 794198398Srdivacky V = Builder.CreateShuffleVector(LHS, RHS, Mask); 795198398Srdivacky ++CurIdx; 796198398Srdivacky continue; 797198398Srdivacky } 798198398Srdivacky } 799198398Srdivacky } 800210299Sed Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 801198398Srdivacky V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 802198398Srdivacky VIsUndefShuffle = false; 803198398Srdivacky ++CurIdx; 804198398Srdivacky continue; 805198398Srdivacky } 806198398Srdivacky 807198398Srdivacky unsigned InitElts = VVT->getNumElements(); 808198398Srdivacky 809198398Srdivacky // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's 810198398Srdivacky // input is the same width as the vector being constructed, generate an 811198398Srdivacky // optimized shuffle of the swizzle input into the result. 812198893Srdivacky unsigned Offset = (CurIdx == 0) ? 0 : ResElts; 813198398Srdivacky if (isa<ExtVectorElementExpr>(IE)) { 814198398Srdivacky llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init); 815198398Srdivacky Value *SVOp = SVI->getOperand(0); 816198398Srdivacky const llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType()); 817198398Srdivacky 818198398Srdivacky if (OpTy->getNumElements() == ResElts) { 819198398Srdivacky for (unsigned j = 0; j != CurIdx; ++j) { 820198398Srdivacky // If the current vector initializer is a shuffle with undef, merge 821198398Srdivacky // this shuffle directly into it. 822198398Srdivacky if (VIsUndefShuffle) { 823198398Srdivacky Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0, 824210299Sed CGF.Int32Ty)); 825198398Srdivacky } else { 826210299Sed Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 827198398Srdivacky } 828198398Srdivacky } 829198398Srdivacky for (unsigned j = 0, je = InitElts; j != je; ++j) 830210299Sed Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty)); 831198398Srdivacky for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 832210299Sed Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 833198398Srdivacky 834198398Srdivacky if (VIsUndefShuffle) 835198398Srdivacky V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 836198398Srdivacky 837198398Srdivacky Init = SVOp; 838198398Srdivacky } 839198398Srdivacky } 840198398Srdivacky 841198398Srdivacky // Extend init to result vector length, and then shuffle its contribution 842198398Srdivacky // to the vector initializer into V. 843198398Srdivacky if (Args.empty()) { 844198398Srdivacky for (unsigned j = 0; j != InitElts; ++j) 845210299Sed Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 846198398Srdivacky for (unsigned j = InitElts; j != ResElts; ++j) 847210299Sed Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 848198398Srdivacky llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 849198398Srdivacky Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), 850198893Srdivacky Mask, "vext"); 851198398Srdivacky 852198398Srdivacky Args.clear(); 853198398Srdivacky for (unsigned j = 0; j != CurIdx; ++j) 854210299Sed Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 855198398Srdivacky for (unsigned j = 0; j != InitElts; ++j) 856210299Sed Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j+Offset)); 857198398Srdivacky for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 858210299Sed Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 859198398Srdivacky } 860198398Srdivacky 861198398Srdivacky // If V is undef, make sure it ends up on the RHS of the shuffle to aid 862198398Srdivacky // merging subsequent shuffles into this one. 863198398Srdivacky if (CurIdx == 0) 864198398Srdivacky std::swap(V, Init); 865198398Srdivacky llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 866198398Srdivacky V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit"); 867198398Srdivacky VIsUndefShuffle = isa<llvm::UndefValue>(Init); 868198398Srdivacky CurIdx += InitElts; 869198398Srdivacky } 870198398Srdivacky 871198398Srdivacky // FIXME: evaluate codegen vs. shuffling against constant null vector. 872198398Srdivacky // Emit remaining default initializers. 873198398Srdivacky const llvm::Type *EltTy = VType->getElementType(); 874198398Srdivacky 875198398Srdivacky // Emit remaining default initializers 876198398Srdivacky for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { 877210299Sed Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 878198398Srdivacky llvm::Value *Init = llvm::Constant::getNullValue(EltTy); 879198398Srdivacky V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 880198398Srdivacky } 881198398Srdivacky return V; 882198398Srdivacky} 883198398Srdivacky 884199990Srdivackystatic bool ShouldNullCheckClassCastValue(const CastExpr *CE) { 885199990Srdivacky const Expr *E = CE->getSubExpr(); 886206084Srdivacky 887212904Sdim if (CE->getCastKind() == CK_UncheckedDerivedToBase) 888206084Srdivacky return false; 889199990Srdivacky 890199990Srdivacky if (isa<CXXThisExpr>(E)) { 891199990Srdivacky // We always assume that 'this' is never null. 892199990Srdivacky return false; 893199990Srdivacky } 894199990Srdivacky 895199990Srdivacky if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) { 896212904Sdim // And that glvalue casts are never null. 897212904Sdim if (ICE->getValueKind() != VK_RValue) 898199990Srdivacky return false; 899199990Srdivacky } 900199990Srdivacky 901199990Srdivacky return true; 902199990Srdivacky} 903199990Srdivacky 904198092Srdivacky// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 905198092Srdivacky// have to handle a more broad range of conversions than explicit casts, as they 906198092Srdivacky// handle things like function to ptr-to-function decay etc. 907199990SrdivackyValue *ScalarExprEmitter::EmitCastExpr(CastExpr *CE) { 908199990Srdivacky Expr *E = CE->getSubExpr(); 909198092Srdivacky QualType DestTy = CE->getType(); 910212904Sdim CastKind Kind = CE->getCastKind(); 911193326Sed 912198092Srdivacky if (!DestTy->isVoidType()) 913198092Srdivacky TestAndClearIgnoreResultAssign(); 914193326Sed 915199990Srdivacky // Since almost all cast kinds apply to scalars, this switch doesn't have 916199990Srdivacky // a default case, so the compiler will warn on a missing case. The cases 917199990Srdivacky // are in the same order as in the CastKind enum. 918198092Srdivacky switch (Kind) { 919212904Sdim case CK_Unknown: 920199990Srdivacky // FIXME: All casts should have a known kind! 921199482Srdivacky //assert(0 && "Unknown cast kind!"); 922198092Srdivacky break; 923199482Srdivacky 924212904Sdim case CK_LValueBitCast: 925212904Sdim case CK_ObjCObjectLValueCast: { 926210299Sed Value *V = EmitLValue(E).getAddress(); 927210299Sed V = Builder.CreateBitCast(V, 928210299Sed ConvertType(CGF.getContext().getPointerType(DestTy))); 929212904Sdim return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), DestTy); 930210299Sed } 931210299Sed 932212904Sdim case CK_AnyPointerToObjCPointerCast: 933212904Sdim case CK_AnyPointerToBlockPointerCast: 934212904Sdim case CK_BitCast: { 935198092Srdivacky Value *Src = Visit(const_cast<Expr*>(E)); 936198092Srdivacky return Builder.CreateBitCast(Src, ConvertType(DestTy)); 937198092Srdivacky } 938212904Sdim case CK_NoOp: 939212904Sdim case CK_UserDefinedConversion: 940199482Srdivacky return Visit(const_cast<Expr*>(E)); 941198092Srdivacky 942212904Sdim case CK_BaseToDerived: { 943199990Srdivacky const CXXRecordDecl *DerivedClassDecl = 944199990Srdivacky DestTy->getCXXRecordDeclForPointerType(); 945199990Srdivacky 946207619Srdivacky return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl, 947212904Sdim CE->path_begin(), CE->path_end(), 948207619Srdivacky ShouldNullCheckClassCastValue(CE)); 949199990Srdivacky } 950212904Sdim case CK_UncheckedDerivedToBase: 951212904Sdim case CK_DerivedToBase: { 952198092Srdivacky const RecordType *DerivedClassTy = 953198092Srdivacky E->getType()->getAs<PointerType>()->getPointeeType()->getAs<RecordType>(); 954198092Srdivacky CXXRecordDecl *DerivedClassDecl = 955198092Srdivacky cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 956193326Sed 957207619Srdivacky return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, 958212904Sdim CE->path_begin(), CE->path_end(), 959207619Srdivacky ShouldNullCheckClassCastValue(CE)); 960198092Srdivacky } 961212904Sdim case CK_Dynamic: { 962199990Srdivacky Value *V = Visit(const_cast<Expr*>(E)); 963199990Srdivacky const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE); 964199990Srdivacky return CGF.EmitDynamicCast(V, DCE); 965199990Srdivacky } 966212904Sdim case CK_ToUnion: 967199482Srdivacky assert(0 && "Should be unreachable!"); 968199482Srdivacky break; 969199990Srdivacky 970212904Sdim case CK_ArrayToPointerDecay: { 971199482Srdivacky assert(E->getType()->isArrayType() && 972199482Srdivacky "Array to pointer decay must have array source type!"); 973193326Sed 974199482Srdivacky Value *V = EmitLValue(E).getAddress(); // Bitfields can't be arrays. 975199482Srdivacky 976199482Srdivacky // Note that VLA pointers are always decayed, so we don't need to do 977199482Srdivacky // anything here. 978199482Srdivacky if (!E->getType()->isVariableArrayType()) { 979199482Srdivacky assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 980199482Srdivacky assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 981199482Srdivacky ->getElementType()) && 982199482Srdivacky "Expected pointer to array"); 983199482Srdivacky V = Builder.CreateStructGEP(V, 0, "arraydecay"); 984199482Srdivacky } 985199482Srdivacky 986199482Srdivacky return V; 987199482Srdivacky } 988212904Sdim case CK_FunctionToPointerDecay: 989199482Srdivacky return EmitLValue(E).getAddress(); 990199482Srdivacky 991212904Sdim case CK_NullToMemberPointer: { 992212904Sdim // If the subexpression's type is the C++0x nullptr_t, emit the 993212904Sdim // subexpression, which may have side effects. 994212904Sdim if (E->getType()->isNullPtrType()) 995212904Sdim (void) Visit(E); 996199482Srdivacky 997212904Sdim const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>(); 998212904Sdim return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 999212904Sdim } 1000212904Sdim 1001212904Sdim case CK_BaseToDerivedMemberPointer: 1002212904Sdim case CK_DerivedToBaseMemberPointer: { 1003199990Srdivacky Value *Src = Visit(E); 1004210299Sed 1005212904Sdim // Note that the AST doesn't distinguish between checked and 1006212904Sdim // unchecked member pointer conversions, so we always have to 1007212904Sdim // implement checked conversions here. This is inefficient when 1008212904Sdim // actual control flow may be required in order to perform the 1009212904Sdim // check, which it is for data member pointers (but not member 1010212904Sdim // function pointers on Itanium and ARM). 1011212904Sdim return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src); 1012199990Srdivacky } 1013212904Sdim 1014199990Srdivacky 1015212904Sdim case CK_ConstructorConversion: 1016199990Srdivacky assert(0 && "Should be unreachable!"); 1017199990Srdivacky break; 1018199990Srdivacky 1019212904Sdim case CK_IntegralToPointer: { 1020198092Srdivacky Value *Src = Visit(const_cast<Expr*>(E)); 1021212904Sdim 1022198398Srdivacky // First, convert to the correct width so that we control the kind of 1023198398Srdivacky // extension. 1024210299Sed const llvm::Type *MiddleTy = CGF.IntPtrTy; 1025198398Srdivacky bool InputSigned = E->getType()->isSignedIntegerType(); 1026198398Srdivacky llvm::Value* IntResult = 1027198398Srdivacky Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 1028212904Sdim 1029198398Srdivacky return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy)); 1030198092Srdivacky } 1031212904Sdim case CK_PointerToIntegral: { 1032198092Srdivacky Value *Src = Visit(const_cast<Expr*>(E)); 1033212904Sdim 1034212904Sdim // Handle conversion to bool correctly. 1035212904Sdim if (DestTy->isBooleanType()) 1036212904Sdim return EmitScalarConversion(Src, E->getType(), DestTy); 1037212904Sdim 1038198092Srdivacky return Builder.CreatePtrToInt(Src, ConvertType(DestTy)); 1039198092Srdivacky } 1040212904Sdim case CK_ToVoid: { 1041212904Sdim if (E->Classify(CGF.getContext()).isGLValue()) 1042212904Sdim CGF.EmitLValue(E); 1043212904Sdim else 1044212904Sdim CGF.EmitAnyExpr(E, 0, false, true); 1045199482Srdivacky return 0; 1046198092Srdivacky } 1047212904Sdim case CK_VectorSplat: { 1048199482Srdivacky const llvm::Type *DstTy = ConvertType(DestTy); 1049199482Srdivacky Value *Elt = Visit(const_cast<Expr*>(E)); 1050199482Srdivacky 1051199482Srdivacky // Insert the element in element zero of an undef vector 1052199482Srdivacky llvm::Value *UnV = llvm::UndefValue::get(DstTy); 1053210299Sed llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 1054199482Srdivacky UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 1055199482Srdivacky 1056199482Srdivacky // Splat the element across to all elements 1057199482Srdivacky llvm::SmallVector<llvm::Constant*, 16> Args; 1058199482Srdivacky unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 1059199482Srdivacky for (unsigned i = 0; i < NumElements; i++) 1060210299Sed Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 0)); 1061199482Srdivacky 1062199482Srdivacky llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 1063199482Srdivacky llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 1064199482Srdivacky return Yay; 1065199482Srdivacky } 1066212904Sdim case CK_IntegralCast: 1067212904Sdim case CK_IntegralToFloating: 1068212904Sdim case CK_FloatingToIntegral: 1069212904Sdim case CK_FloatingCast: 1070199990Srdivacky return EmitScalarConversion(Visit(E), E->getType(), DestTy); 1071199482Srdivacky 1072212904Sdim case CK_MemberPointerToBoolean: { 1073212904Sdim llvm::Value *MemPtr = Visit(E); 1074212904Sdim const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>(); 1075212904Sdim return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT); 1076199482Srdivacky } 1077212904Sdim } 1078212904Sdim 1079193326Sed // Handle cases where the source is an non-complex type. 1080198092Srdivacky 1081193326Sed if (!CGF.hasAggregateLLVMType(E->getType())) { 1082193326Sed Value *Src = Visit(const_cast<Expr*>(E)); 1083193326Sed 1084193326Sed // Use EmitScalarConversion to perform the conversion. 1085193326Sed return EmitScalarConversion(Src, E->getType(), DestTy); 1086193326Sed } 1087198092Srdivacky 1088193326Sed if (E->getType()->isAnyComplexType()) { 1089193326Sed // Handle cases where the source is a complex type. 1090193326Sed bool IgnoreImag = true; 1091193326Sed bool IgnoreImagAssign = true; 1092193326Sed bool IgnoreReal = IgnoreResultAssign; 1093193326Sed bool IgnoreRealAssign = IgnoreResultAssign; 1094193326Sed if (DestTy->isBooleanType()) 1095193326Sed IgnoreImagAssign = IgnoreImag = false; 1096193326Sed else if (DestTy->isVoidType()) { 1097193326Sed IgnoreReal = IgnoreImag = false; 1098193326Sed IgnoreRealAssign = IgnoreImagAssign = true; 1099193326Sed } 1100193326Sed CodeGenFunction::ComplexPairTy V 1101193326Sed = CGF.EmitComplexExpr(E, IgnoreReal, IgnoreImag, IgnoreRealAssign, 1102193326Sed IgnoreImagAssign); 1103193326Sed return EmitComplexToScalarConversion(V, E->getType(), DestTy); 1104193326Sed } 1105193326Sed 1106193326Sed // Okay, this is a cast from an aggregate. It must be a cast to void. Just 1107193326Sed // evaluate the result and return. 1108193326Sed CGF.EmitAggExpr(E, 0, false, true); 1109193326Sed return 0; 1110193326Sed} 1111193326Sed 1112193326SedValue *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 1113193326Sed return CGF.EmitCompoundStmt(*E->getSubStmt(), 1114193326Sed !E->getType()->isVoidType()).getScalarVal(); 1115193326Sed} 1116193326Sed 1117193326SedValue *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 1118198092Srdivacky llvm::Value *V = CGF.GetAddrOfBlockDecl(E); 1119198092Srdivacky if (E->getType().isObjCGCWeak()) 1120198092Srdivacky return CGF.CGM.getObjCRuntime().EmitObjCWeakRead(CGF, V); 1121212904Sdim return CGF.EmitLoadOfScalar(V, false, 0, E->getType()); 1122193326Sed} 1123193326Sed 1124193326Sed//===----------------------------------------------------------------------===// 1125193326Sed// Unary Operators 1126193326Sed//===----------------------------------------------------------------------===// 1127193326Sed 1128210299Sedllvm::Value *ScalarExprEmitter:: 1129210299SedEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 1130210299Sed bool isInc, bool isPre) { 1131210299Sed 1132210299Sed QualType ValTy = E->getSubExpr()->getType(); 1133210299Sed llvm::Value *InVal = EmitLoadOfLValue(LV, ValTy); 1134210299Sed 1135210299Sed int AmountVal = isInc ? 1 : -1; 1136210299Sed 1137210299Sed if (ValTy->isPointerType() && 1138210299Sed ValTy->getAs<PointerType>()->isVariableArrayType()) { 1139210299Sed // The amount of the addition/subtraction needs to account for the VLA size 1140210299Sed CGF.ErrorUnsupported(E, "VLA pointer inc/dec"); 1141210299Sed } 1142210299Sed 1143210299Sed llvm::Value *NextVal; 1144210299Sed if (const llvm::PointerType *PT = 1145210299Sed dyn_cast<llvm::PointerType>(InVal->getType())) { 1146210299Sed llvm::Constant *Inc = llvm::ConstantInt::get(CGF.Int32Ty, AmountVal); 1147210299Sed if (!isa<llvm::FunctionType>(PT->getElementType())) { 1148210299Sed QualType PTEE = ValTy->getPointeeType(); 1149210299Sed if (const ObjCObjectType *OIT = PTEE->getAs<ObjCObjectType>()) { 1150210299Sed // Handle interface types, which are not represented with a concrete 1151210299Sed // type. 1152210299Sed int size = CGF.getContext().getTypeSize(OIT) / 8; 1153210299Sed if (!isInc) 1154210299Sed size = -size; 1155210299Sed Inc = llvm::ConstantInt::get(Inc->getType(), size); 1156210299Sed const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1157210299Sed InVal = Builder.CreateBitCast(InVal, i8Ty); 1158210299Sed NextVal = Builder.CreateGEP(InVal, Inc, "add.ptr"); 1159210299Sed llvm::Value *lhs = LV.getAddress(); 1160210299Sed lhs = Builder.CreateBitCast(lhs, llvm::PointerType::getUnqual(i8Ty)); 1161212904Sdim LV = CGF.MakeAddrLValue(lhs, ValTy); 1162210299Sed } else 1163210299Sed NextVal = Builder.CreateInBoundsGEP(InVal, Inc, "ptrincdec"); 1164210299Sed } else { 1165210299Sed const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1166210299Sed NextVal = Builder.CreateBitCast(InVal, i8Ty, "tmp"); 1167210299Sed NextVal = Builder.CreateGEP(NextVal, Inc, "ptrincdec"); 1168210299Sed NextVal = Builder.CreateBitCast(NextVal, InVal->getType()); 1169210299Sed } 1170210299Sed } else if (InVal->getType()->isIntegerTy(1) && isInc) { 1171210299Sed // Bool++ is an interesting case, due to promotion rules, we get: 1172210299Sed // Bool++ -> Bool = Bool+1 -> Bool = (int)Bool+1 -> 1173210299Sed // Bool = ((int)Bool+1) != 0 1174210299Sed // An interesting aspect of this is that increment is always true. 1175210299Sed // Decrement does not have this property. 1176210299Sed NextVal = llvm::ConstantInt::getTrue(VMContext); 1177210299Sed } else if (isa<llvm::IntegerType>(InVal->getType())) { 1178210299Sed NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal); 1179210299Sed 1180210299Sed if (!ValTy->isSignedIntegerType()) 1181210299Sed // Unsigned integer inc is always two's complement. 1182210299Sed NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1183210299Sed else { 1184210299Sed switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1185210299Sed case LangOptions::SOB_Undefined: 1186210299Sed NextVal = Builder.CreateNSWAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1187210299Sed break; 1188210299Sed case LangOptions::SOB_Defined: 1189210299Sed NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1190210299Sed break; 1191210299Sed case LangOptions::SOB_Trapping: 1192210299Sed BinOpInfo BinOp; 1193210299Sed BinOp.LHS = InVal; 1194210299Sed BinOp.RHS = NextVal; 1195210299Sed BinOp.Ty = E->getType(); 1196212904Sdim BinOp.Opcode = BO_Add; 1197210299Sed BinOp.E = E; 1198212904Sdim NextVal = EmitOverflowCheckedBinOp(BinOp); 1199212904Sdim break; 1200210299Sed } 1201210299Sed } 1202210299Sed } else { 1203210299Sed // Add the inc/dec to the real part. 1204210299Sed if (InVal->getType()->isFloatTy()) 1205210299Sed NextVal = 1206210299Sed llvm::ConstantFP::get(VMContext, 1207210299Sed llvm::APFloat(static_cast<float>(AmountVal))); 1208210299Sed else if (InVal->getType()->isDoubleTy()) 1209210299Sed NextVal = 1210210299Sed llvm::ConstantFP::get(VMContext, 1211210299Sed llvm::APFloat(static_cast<double>(AmountVal))); 1212210299Sed else { 1213210299Sed llvm::APFloat F(static_cast<float>(AmountVal)); 1214210299Sed bool ignored; 1215210299Sed F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 1216210299Sed &ignored); 1217210299Sed NextVal = llvm::ConstantFP::get(VMContext, F); 1218210299Sed } 1219210299Sed NextVal = Builder.CreateFAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1220210299Sed } 1221210299Sed 1222210299Sed // Store the updated result through the lvalue. 1223210299Sed if (LV.isBitField()) 1224210299Sed CGF.EmitStoreThroughBitfieldLValue(RValue::get(NextVal), LV, ValTy, &NextVal); 1225210299Sed else 1226210299Sed CGF.EmitStoreThroughLValue(RValue::get(NextVal), LV, ValTy); 1227210299Sed 1228210299Sed // If this is a postinc, return the value read from memory, otherwise use the 1229210299Sed // updated value. 1230210299Sed return isPre ? NextVal : InVal; 1231210299Sed} 1232210299Sed 1233210299Sed 1234210299Sed 1235193326SedValue *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 1236193326Sed TestAndClearIgnoreResultAssign(); 1237210299Sed // Emit unary minus with EmitSub so we handle overflow cases etc. 1238210299Sed BinOpInfo BinOp; 1239210299Sed BinOp.RHS = Visit(E->getSubExpr()); 1240210299Sed 1241210299Sed if (BinOp.RHS->getType()->isFPOrFPVectorTy()) 1242210299Sed BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType()); 1243210299Sed else 1244210299Sed BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType()); 1245210299Sed BinOp.Ty = E->getType(); 1246212904Sdim BinOp.Opcode = BO_Sub; 1247210299Sed BinOp.E = E; 1248210299Sed return EmitSub(BinOp); 1249193326Sed} 1250193326Sed 1251193326SedValue *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 1252193326Sed TestAndClearIgnoreResultAssign(); 1253193326Sed Value *Op = Visit(E->getSubExpr()); 1254193326Sed return Builder.CreateNot(Op, "neg"); 1255193326Sed} 1256193326Sed 1257193326SedValue *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 1258193326Sed // Compare operand to zero. 1259193326Sed Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 1260198092Srdivacky 1261193326Sed // Invert value. 1262193326Sed // TODO: Could dynamically modify easy computations here. For example, if 1263193326Sed // the operand is an icmp ne, turn into icmp eq. 1264193326Sed BoolVal = Builder.CreateNot(BoolVal, "lnot"); 1265198092Srdivacky 1266193326Sed // ZExt result to the expr type. 1267193326Sed return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext"); 1268193326Sed} 1269193326Sed 1270212904SdimValue *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) { 1271212904Sdim // Try folding the offsetof to a constant. 1272212904Sdim Expr::EvalResult EvalResult; 1273212904Sdim if (E->Evaluate(EvalResult, CGF.getContext())) 1274212904Sdim return llvm::ConstantInt::get(VMContext, EvalResult.Val.getInt()); 1275212904Sdim 1276212904Sdim // Loop over the components of the offsetof to compute the value. 1277212904Sdim unsigned n = E->getNumComponents(); 1278212904Sdim const llvm::Type* ResultType = ConvertType(E->getType()); 1279212904Sdim llvm::Value* Result = llvm::Constant::getNullValue(ResultType); 1280212904Sdim QualType CurrentType = E->getTypeSourceInfo()->getType(); 1281212904Sdim for (unsigned i = 0; i != n; ++i) { 1282212904Sdim OffsetOfExpr::OffsetOfNode ON = E->getComponent(i); 1283212904Sdim llvm::Value *Offset = 0; 1284212904Sdim switch (ON.getKind()) { 1285212904Sdim case OffsetOfExpr::OffsetOfNode::Array: { 1286212904Sdim // Compute the index 1287212904Sdim Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex()); 1288212904Sdim llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr); 1289212904Sdim bool IdxSigned = IdxExpr->getType()->isSignedIntegerType(); 1290212904Sdim Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv"); 1291212904Sdim 1292212904Sdim // Save the element type 1293212904Sdim CurrentType = 1294212904Sdim CGF.getContext().getAsArrayType(CurrentType)->getElementType(); 1295212904Sdim 1296212904Sdim // Compute the element size 1297212904Sdim llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType, 1298212904Sdim CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity()); 1299212904Sdim 1300212904Sdim // Multiply out to compute the result 1301212904Sdim Offset = Builder.CreateMul(Idx, ElemSize); 1302212904Sdim break; 1303212904Sdim } 1304212904Sdim 1305212904Sdim case OffsetOfExpr::OffsetOfNode::Field: { 1306212904Sdim FieldDecl *MemberDecl = ON.getField(); 1307212904Sdim RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 1308212904Sdim const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 1309212904Sdim 1310212904Sdim // Compute the index of the field in its parent. 1311212904Sdim unsigned i = 0; 1312212904Sdim // FIXME: It would be nice if we didn't have to loop here! 1313212904Sdim for (RecordDecl::field_iterator Field = RD->field_begin(), 1314212904Sdim FieldEnd = RD->field_end(); 1315212904Sdim Field != FieldEnd; (void)++Field, ++i) { 1316212904Sdim if (*Field == MemberDecl) 1317212904Sdim break; 1318212904Sdim } 1319212904Sdim assert(i < RL.getFieldCount() && "offsetof field in wrong type"); 1320212904Sdim 1321212904Sdim // Compute the offset to the field 1322212904Sdim int64_t OffsetInt = RL.getFieldOffset(i) / 1323212904Sdim CGF.getContext().getCharWidth(); 1324212904Sdim Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 1325212904Sdim 1326212904Sdim // Save the element type. 1327212904Sdim CurrentType = MemberDecl->getType(); 1328212904Sdim break; 1329212904Sdim } 1330212904Sdim 1331212904Sdim case OffsetOfExpr::OffsetOfNode::Identifier: 1332212904Sdim llvm_unreachable("dependent __builtin_offsetof"); 1333212904Sdim 1334212904Sdim case OffsetOfExpr::OffsetOfNode::Base: { 1335212904Sdim if (ON.getBase()->isVirtual()) { 1336212904Sdim CGF.ErrorUnsupported(E, "virtual base in offsetof"); 1337212904Sdim continue; 1338212904Sdim } 1339212904Sdim 1340212904Sdim RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 1341212904Sdim const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 1342212904Sdim 1343212904Sdim // Save the element type. 1344212904Sdim CurrentType = ON.getBase()->getType(); 1345212904Sdim 1346212904Sdim // Compute the offset to the base. 1347212904Sdim const RecordType *BaseRT = CurrentType->getAs<RecordType>(); 1348212904Sdim CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl()); 1349212904Sdim int64_t OffsetInt = RL.getBaseClassOffset(BaseRD) / 1350212904Sdim CGF.getContext().getCharWidth(); 1351212904Sdim Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 1352212904Sdim break; 1353212904Sdim } 1354212904Sdim } 1355212904Sdim Result = Builder.CreateAdd(Result, Offset); 1356212904Sdim } 1357212904Sdim return Result; 1358207619Srdivacky} 1359207619Srdivacky 1360193326Sed/// VisitSizeOfAlignOfExpr - Return the size or alignment of the type of 1361193326Sed/// argument of the sizeof expression as an integer. 1362193326SedValue * 1363193326SedScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) { 1364193326Sed QualType TypeToSize = E->getTypeOfArgument(); 1365193326Sed if (E->isSizeOf()) { 1366198092Srdivacky if (const VariableArrayType *VAT = 1367193326Sed CGF.getContext().getAsVariableArrayType(TypeToSize)) { 1368193326Sed if (E->isArgumentType()) { 1369193326Sed // sizeof(type) - make sure to emit the VLA size. 1370193326Sed CGF.EmitVLASize(TypeToSize); 1371193326Sed } else { 1372193326Sed // C99 6.5.3.4p2: If the argument is an expression of type 1373193326Sed // VLA, it is evaluated. 1374193326Sed CGF.EmitAnyExpr(E->getArgumentExpr()); 1375193326Sed } 1376198092Srdivacky 1377193326Sed return CGF.GetVLASize(VAT); 1378193326Sed } 1379193326Sed } 1380193326Sed 1381198092Srdivacky // If this isn't sizeof(vla), the result must be constant; use the constant 1382198092Srdivacky // folding logic so we don't have to duplicate it here. 1383193326Sed Expr::EvalResult Result; 1384193326Sed E->Evaluate(Result, CGF.getContext()); 1385198092Srdivacky return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 1386193326Sed} 1387193326Sed 1388193326SedValue *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 1389193326Sed Expr *Op = E->getSubExpr(); 1390193326Sed if (Op->getType()->isAnyComplexType()) 1391193326Sed return CGF.EmitComplexExpr(Op, false, true, false, true).first; 1392193326Sed return Visit(Op); 1393193326Sed} 1394193326SedValue *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 1395193326Sed Expr *Op = E->getSubExpr(); 1396193326Sed if (Op->getType()->isAnyComplexType()) 1397193326Sed return CGF.EmitComplexExpr(Op, true, false, true, false).second; 1398198092Srdivacky 1399193326Sed // __imag on a scalar returns zero. Emit the subexpr to ensure side 1400193326Sed // effects are evaluated, but not the actual value. 1401193326Sed if (E->isLvalue(CGF.getContext()) == Expr::LV_Valid) 1402193326Sed CGF.EmitLValue(Op); 1403193326Sed else 1404193326Sed CGF.EmitScalarExpr(Op, true); 1405193326Sed return llvm::Constant::getNullValue(ConvertType(E->getType())); 1406193326Sed} 1407193326Sed 1408193326Sed//===----------------------------------------------------------------------===// 1409193326Sed// Binary Operators 1410193326Sed//===----------------------------------------------------------------------===// 1411193326Sed 1412193326SedBinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 1413193326Sed TestAndClearIgnoreResultAssign(); 1414193326Sed BinOpInfo Result; 1415193326Sed Result.LHS = Visit(E->getLHS()); 1416193326Sed Result.RHS = Visit(E->getRHS()); 1417193326Sed Result.Ty = E->getType(); 1418210299Sed Result.Opcode = E->getOpcode(); 1419193326Sed Result.E = E; 1420193326Sed return Result; 1421193326Sed} 1422193326Sed 1423207619SrdivackyLValue ScalarExprEmitter::EmitCompoundAssignLValue( 1424207619Srdivacky const CompoundAssignOperator *E, 1425207619Srdivacky Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), 1426210299Sed Value *&Result) { 1427201361Srdivacky QualType LHSTy = E->getLHS()->getType(); 1428193326Sed BinOpInfo OpInfo; 1429207619Srdivacky 1430193326Sed if (E->getComputationResultType()->isAnyComplexType()) { 1431198092Srdivacky // This needs to go through the complex expression emitter, but it's a tad 1432198092Srdivacky // complicated to do that... I'm leaving it out for now. (Note that we do 1433198092Srdivacky // actually need the imaginary part of the RHS for multiplication and 1434198092Srdivacky // division.) 1435193326Sed CGF.ErrorUnsupported(E, "complex compound assignment"); 1436210299Sed Result = llvm::UndefValue::get(CGF.ConvertType(E->getType())); 1437207619Srdivacky return LValue(); 1438193326Sed } 1439207619Srdivacky 1440193326Sed // Emit the RHS first. __block variables need to have the rhs evaluated 1441193326Sed // first, plus this should improve codegen a little. 1442193326Sed OpInfo.RHS = Visit(E->getRHS()); 1443193326Sed OpInfo.Ty = E->getComputationResultType(); 1444210299Sed OpInfo.Opcode = E->getOpcode(); 1445193326Sed OpInfo.E = E; 1446193326Sed // Load/convert the LHS. 1447201361Srdivacky LValue LHSLV = EmitCheckedLValue(E->getLHS()); 1448193326Sed OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy); 1449193326Sed OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 1450193326Sed E->getComputationLHSType()); 1451207619Srdivacky 1452193326Sed // Expand the binary operator. 1453210299Sed Result = (this->*Func)(OpInfo); 1454207619Srdivacky 1455193326Sed // Convert the result back to the LHS type. 1456193326Sed Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 1457207619Srdivacky 1458198092Srdivacky // Store the result value into the LHS lvalue. Bit-fields are handled 1459198092Srdivacky // specially because the result is altered by the store, i.e., [C99 6.5.16p1] 1460198092Srdivacky // 'An assignment expression has the value of the left operand after the 1461198092Srdivacky // assignment...'. 1462210299Sed if (LHSLV.isBitField()) 1463210299Sed CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy, 1464210299Sed &Result); 1465210299Sed else 1466193326Sed CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy); 1467210299Sed 1468207619Srdivacky return LHSLV; 1469207619Srdivacky} 1470207619Srdivacky 1471207619SrdivackyValue *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 1472207619Srdivacky Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 1473207619Srdivacky bool Ignore = TestAndClearIgnoreResultAssign(); 1474210299Sed Value *RHS; 1475210299Sed LValue LHS = EmitCompoundAssignLValue(E, Func, RHS); 1476210299Sed 1477210299Sed // If the result is clearly ignored, return now. 1478193326Sed if (Ignore) 1479193326Sed return 0; 1480210299Sed 1481210299Sed // Objective-C property assignment never reloads the value following a store. 1482210299Sed if (LHS.isPropertyRef() || LHS.isKVCRef()) 1483210299Sed return RHS; 1484210299Sed 1485210299Sed // If the lvalue is non-volatile, return the computed value of the assignment. 1486210299Sed if (!LHS.isVolatileQualified()) 1487210299Sed return RHS; 1488210299Sed 1489210299Sed // Otherwise, reload the value. 1490210299Sed return EmitLoadOfLValue(LHS, E->getType()); 1491193326Sed} 1492193326Sed 1493193326Sed 1494193326SedValue *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 1495203955Srdivacky if (Ops.LHS->getType()->isFPOrFPVectorTy()) 1496193326Sed return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 1497212904Sdim else if (Ops.Ty->hasUnsignedIntegerRepresentation()) 1498193326Sed return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 1499193326Sed else 1500193326Sed return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 1501193326Sed} 1502193326Sed 1503193326SedValue *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 1504193326Sed // Rem in C can't be a floating point type: C99 6.5.5p2. 1505193326Sed if (Ops.Ty->isUnsignedIntegerType()) 1506193326Sed return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 1507193326Sed else 1508193326Sed return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 1509193326Sed} 1510193326Sed 1511193326SedValue *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 1512193326Sed unsigned IID; 1513193326Sed unsigned OpID = 0; 1514193326Sed 1515210299Sed switch (Ops.Opcode) { 1516212904Sdim case BO_Add: 1517212904Sdim case BO_AddAssign: 1518193326Sed OpID = 1; 1519193326Sed IID = llvm::Intrinsic::sadd_with_overflow; 1520193326Sed break; 1521212904Sdim case BO_Sub: 1522212904Sdim case BO_SubAssign: 1523193326Sed OpID = 2; 1524193326Sed IID = llvm::Intrinsic::ssub_with_overflow; 1525193326Sed break; 1526212904Sdim case BO_Mul: 1527212904Sdim case BO_MulAssign: 1528193326Sed OpID = 3; 1529193326Sed IID = llvm::Intrinsic::smul_with_overflow; 1530193326Sed break; 1531193326Sed default: 1532193326Sed assert(false && "Unsupported operation for overflow detection"); 1533193326Sed IID = 0; 1534193326Sed } 1535193326Sed OpID <<= 1; 1536193326Sed OpID |= 1; 1537193326Sed 1538193326Sed const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 1539193326Sed 1540193326Sed llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1); 1541193326Sed 1542193326Sed Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 1543193326Sed Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 1544193326Sed Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 1545193326Sed 1546193326Sed // Branch in case of overflow. 1547212904Sdim llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 1548212904Sdim llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn); 1549193326Sed 1550193326Sed Builder.CreateCondBr(overflow, overflowBB, continueBB); 1551193326Sed 1552212904Sdim // Handle overflow with llvm.trap. 1553212904Sdim // TODO: it would be better to generate one of these blocks per function. 1554193326Sed Builder.SetInsertPoint(overflowBB); 1555212904Sdim llvm::Function *Trap = CGF.CGM.getIntrinsic(llvm::Intrinsic::trap); 1556212904Sdim Builder.CreateCall(Trap); 1557212904Sdim Builder.CreateUnreachable(); 1558212904Sdim 1559212904Sdim // Continue on. 1560193326Sed Builder.SetInsertPoint(continueBB); 1561212904Sdim return result; 1562193326Sed} 1563193326Sed 1564193326SedValue *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { 1565198092Srdivacky if (!Ops.Ty->isAnyPointerType()) { 1566212904Sdim if (Ops.Ty->hasSignedIntegerRepresentation()) { 1567210299Sed switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1568210299Sed case LangOptions::SOB_Undefined: 1569210299Sed return Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "add"); 1570210299Sed case LangOptions::SOB_Defined: 1571210299Sed return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 1572210299Sed case LangOptions::SOB_Trapping: 1573210299Sed return EmitOverflowCheckedBinOp(Ops); 1574210299Sed } 1575210299Sed } 1576210299Sed 1577203955Srdivacky if (Ops.LHS->getType()->isFPOrFPVectorTy()) 1578194613Sed return Builder.CreateFAdd(Ops.LHS, Ops.RHS, "add"); 1579198092Srdivacky 1580193326Sed return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 1581193326Sed } 1582193326Sed 1583210299Sed // Must have binary (not unary) expr here. Unary pointer decrement doesn't 1584210299Sed // use this path. 1585210299Sed const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 1586210299Sed 1587198092Srdivacky if (Ops.Ty->isPointerType() && 1588198092Srdivacky Ops.Ty->getAs<PointerType>()->isVariableArrayType()) { 1589193326Sed // The amount of the addition needs to account for the VLA size 1590210299Sed CGF.ErrorUnsupported(BinOp, "VLA pointer addition"); 1591193326Sed } 1592210299Sed 1593193326Sed Value *Ptr, *Idx; 1594193326Sed Expr *IdxExp; 1595210299Sed const PointerType *PT = BinOp->getLHS()->getType()->getAs<PointerType>(); 1596198092Srdivacky const ObjCObjectPointerType *OPT = 1597210299Sed BinOp->getLHS()->getType()->getAs<ObjCObjectPointerType>(); 1598198092Srdivacky if (PT || OPT) { 1599193326Sed Ptr = Ops.LHS; 1600193326Sed Idx = Ops.RHS; 1601210299Sed IdxExp = BinOp->getRHS(); 1602198092Srdivacky } else { // int + pointer 1603210299Sed PT = BinOp->getRHS()->getType()->getAs<PointerType>(); 1604210299Sed OPT = BinOp->getRHS()->getType()->getAs<ObjCObjectPointerType>(); 1605198092Srdivacky assert((PT || OPT) && "Invalid add expr"); 1606193326Sed Ptr = Ops.RHS; 1607193326Sed Idx = Ops.LHS; 1608210299Sed IdxExp = BinOp->getLHS(); 1609193326Sed } 1610193326Sed 1611193326Sed unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 1612193326Sed if (Width < CGF.LLVMPointerWidth) { 1613193326Sed // Zero or sign extend the pointer value based on whether the index is 1614193326Sed // signed or not. 1615210299Sed const llvm::Type *IdxType = CGF.IntPtrTy; 1616193326Sed if (IdxExp->getType()->isSignedIntegerType()) 1617193326Sed Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 1618193326Sed else 1619193326Sed Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 1620193326Sed } 1621198092Srdivacky const QualType ElementType = PT ? PT->getPointeeType() : OPT->getPointeeType(); 1622198092Srdivacky // Handle interface types, which are not represented with a concrete type. 1623208600Srdivacky if (const ObjCObjectType *OIT = ElementType->getAs<ObjCObjectType>()) { 1624198092Srdivacky llvm::Value *InterfaceSize = 1625193326Sed llvm::ConstantInt::get(Idx->getType(), 1626202379Srdivacky CGF.getContext().getTypeSizeInChars(OIT).getQuantity()); 1627193326Sed Idx = Builder.CreateMul(Idx, InterfaceSize); 1628198092Srdivacky const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1629193326Sed Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 1630193326Sed Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 1631193326Sed return Builder.CreateBitCast(Res, Ptr->getType()); 1632198092Srdivacky } 1633193326Sed 1634198092Srdivacky // Explicitly handle GNU void* and function pointer arithmetic extensions. The 1635198092Srdivacky // GNU void* casts amount to no-ops since our void* type is i8*, but this is 1636198092Srdivacky // future proof. 1637193326Sed if (ElementType->isVoidType() || ElementType->isFunctionType()) { 1638198092Srdivacky const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1639193326Sed Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 1640193326Sed Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 1641193326Sed return Builder.CreateBitCast(Res, Ptr->getType()); 1642198092Srdivacky } 1643198092Srdivacky 1644198092Srdivacky return Builder.CreateInBoundsGEP(Ptr, Idx, "add.ptr"); 1645193326Sed} 1646193326Sed 1647193326SedValue *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { 1648193326Sed if (!isa<llvm::PointerType>(Ops.LHS->getType())) { 1649212904Sdim if (Ops.Ty->hasSignedIntegerRepresentation()) { 1650210299Sed switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1651210299Sed case LangOptions::SOB_Undefined: 1652210299Sed return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub"); 1653210299Sed case LangOptions::SOB_Defined: 1654210299Sed return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 1655210299Sed case LangOptions::SOB_Trapping: 1656210299Sed return EmitOverflowCheckedBinOp(Ops); 1657210299Sed } 1658210299Sed } 1659210299Sed 1660203955Srdivacky if (Ops.LHS->getType()->isFPOrFPVectorTy()) 1661194613Sed return Builder.CreateFSub(Ops.LHS, Ops.RHS, "sub"); 1662206084Srdivacky 1663193326Sed return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 1664193326Sed } 1665193326Sed 1666210299Sed // Must have binary (not unary) expr here. Unary pointer increment doesn't 1667210299Sed // use this path. 1668210299Sed const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 1669210299Sed 1670210299Sed if (BinOp->getLHS()->getType()->isPointerType() && 1671210299Sed BinOp->getLHS()->getType()->getAs<PointerType>()->isVariableArrayType()) { 1672193326Sed // The amount of the addition needs to account for the VLA size for 1673193326Sed // ptr-int 1674193326Sed // The amount of the division needs to account for the VLA size for 1675193326Sed // ptr-ptr. 1676210299Sed CGF.ErrorUnsupported(BinOp, "VLA pointer subtraction"); 1677193326Sed } 1678193326Sed 1679210299Sed const QualType LHSType = BinOp->getLHS()->getType(); 1680198092Srdivacky const QualType LHSElementType = LHSType->getPointeeType(); 1681193326Sed if (!isa<llvm::PointerType>(Ops.RHS->getType())) { 1682193326Sed // pointer - int 1683193326Sed Value *Idx = Ops.RHS; 1684193326Sed unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 1685193326Sed if (Width < CGF.LLVMPointerWidth) { 1686193326Sed // Zero or sign extend the pointer value based on whether the index is 1687193326Sed // signed or not. 1688210299Sed const llvm::Type *IdxType = CGF.IntPtrTy; 1689210299Sed if (BinOp->getRHS()->getType()->isSignedIntegerType()) 1690193326Sed Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 1691193326Sed else 1692193326Sed Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 1693193326Sed } 1694193326Sed Idx = Builder.CreateNeg(Idx, "sub.ptr.neg"); 1695193326Sed 1696198092Srdivacky // Handle interface types, which are not represented with a concrete type. 1697208600Srdivacky if (const ObjCObjectType *OIT = LHSElementType->getAs<ObjCObjectType>()) { 1698198092Srdivacky llvm::Value *InterfaceSize = 1699193326Sed llvm::ConstantInt::get(Idx->getType(), 1700202379Srdivacky CGF.getContext(). 1701202379Srdivacky getTypeSizeInChars(OIT).getQuantity()); 1702193326Sed Idx = Builder.CreateMul(Idx, InterfaceSize); 1703198092Srdivacky const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1704193326Sed Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1705193326Sed Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr"); 1706193326Sed return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1707198092Srdivacky } 1708193326Sed 1709193326Sed // Explicitly handle GNU void* and function pointer arithmetic 1710198092Srdivacky // extensions. The GNU void* casts amount to no-ops since our void* type is 1711198092Srdivacky // i8*, but this is future proof. 1712193326Sed if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 1713198092Srdivacky const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1714193326Sed Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1715193326Sed Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr"); 1716193326Sed return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1717198092Srdivacky } 1718198092Srdivacky 1719198092Srdivacky return Builder.CreateInBoundsGEP(Ops.LHS, Idx, "sub.ptr"); 1720193326Sed } else { 1721193326Sed // pointer - pointer 1722193326Sed Value *LHS = Ops.LHS; 1723193326Sed Value *RHS = Ops.RHS; 1724198092Srdivacky 1725202379Srdivacky CharUnits ElementSize; 1726193326Sed 1727193326Sed // Handle GCC extension for pointer arithmetic on void* and function pointer 1728193326Sed // types. 1729193326Sed if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 1730202379Srdivacky ElementSize = CharUnits::One(); 1731193326Sed } else { 1732202379Srdivacky ElementSize = CGF.getContext().getTypeSizeInChars(LHSElementType); 1733193326Sed } 1734198092Srdivacky 1735193326Sed const llvm::Type *ResultType = ConvertType(Ops.Ty); 1736193326Sed LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); 1737193326Sed RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 1738193326Sed Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 1739198092Srdivacky 1740193326Sed // Optimize out the shift for element size of 1. 1741202379Srdivacky if (ElementSize.isOne()) 1742193326Sed return BytesBetween; 1743198092Srdivacky 1744198092Srdivacky // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 1745198092Srdivacky // pointer difference in C is only defined in the case where both operands 1746198092Srdivacky // are pointing to elements of an array. 1747202379Srdivacky Value *BytesPerElt = 1748202379Srdivacky llvm::ConstantInt::get(ResultType, ElementSize.getQuantity()); 1749198092Srdivacky return Builder.CreateExactSDiv(BytesBetween, BytesPerElt, "sub.ptr.div"); 1750193326Sed } 1751193326Sed} 1752193326Sed 1753193326SedValue *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 1754193326Sed // LLVM requires the LHS and RHS to be the same type: promote or truncate the 1755193326Sed // RHS to the same size as the LHS. 1756193326Sed Value *RHS = Ops.RHS; 1757193326Sed if (Ops.LHS->getType() != RHS->getType()) 1758193326Sed RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1759198092Srdivacky 1760200583Srdivacky if (CGF.CatchUndefined 1761200583Srdivacky && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1762200583Srdivacky unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1763200583Srdivacky llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1764200583Srdivacky CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1765200583Srdivacky llvm::ConstantInt::get(RHS->getType(), Width)), 1766200583Srdivacky Cont, CGF.getTrapBB()); 1767200583Srdivacky CGF.EmitBlock(Cont); 1768200583Srdivacky } 1769200583Srdivacky 1770193326Sed return Builder.CreateShl(Ops.LHS, RHS, "shl"); 1771193326Sed} 1772193326Sed 1773193326SedValue *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 1774193326Sed // LLVM requires the LHS and RHS to be the same type: promote or truncate the 1775193326Sed // RHS to the same size as the LHS. 1776193326Sed Value *RHS = Ops.RHS; 1777193326Sed if (Ops.LHS->getType() != RHS->getType()) 1778193326Sed RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1779198092Srdivacky 1780200583Srdivacky if (CGF.CatchUndefined 1781200583Srdivacky && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1782200583Srdivacky unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1783200583Srdivacky llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1784200583Srdivacky CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1785200583Srdivacky llvm::ConstantInt::get(RHS->getType(), Width)), 1786200583Srdivacky Cont, CGF.getTrapBB()); 1787200583Srdivacky CGF.EmitBlock(Cont); 1788200583Srdivacky } 1789200583Srdivacky 1790212904Sdim if (Ops.Ty->hasUnsignedIntegerRepresentation()) 1791193326Sed return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 1792193326Sed return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 1793193326Sed} 1794193326Sed 1795193326SedValue *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 1796193326Sed unsigned SICmpOpc, unsigned FCmpOpc) { 1797193326Sed TestAndClearIgnoreResultAssign(); 1798193326Sed Value *Result; 1799193326Sed QualType LHSTy = E->getLHS()->getType(); 1800212904Sdim if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) { 1801212904Sdim assert(E->getOpcode() == BO_EQ || 1802212904Sdim E->getOpcode() == BO_NE); 1803212904Sdim Value *LHS = CGF.EmitScalarExpr(E->getLHS()); 1804212904Sdim Value *RHS = CGF.EmitScalarExpr(E->getRHS()); 1805212904Sdim Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison( 1806212904Sdim CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE); 1807200583Srdivacky } else if (!LHSTy->isAnyComplexType()) { 1808193326Sed Value *LHS = Visit(E->getLHS()); 1809193326Sed Value *RHS = Visit(E->getRHS()); 1810198092Srdivacky 1811203955Srdivacky if (LHS->getType()->isFPOrFPVectorTy()) { 1812193326Sed Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 1813193326Sed LHS, RHS, "cmp"); 1814212904Sdim } else if (LHSTy->hasSignedIntegerRepresentation()) { 1815193326Sed Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 1816193326Sed LHS, RHS, "cmp"); 1817193326Sed } else { 1818193326Sed // Unsigned integers and pointers. 1819193326Sed Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1820193326Sed LHS, RHS, "cmp"); 1821193326Sed } 1822198092Srdivacky 1823198092Srdivacky // If this is a vector comparison, sign extend the result to the appropriate 1824198092Srdivacky // vector integer type and return it (don't convert to bool). 1825198092Srdivacky if (LHSTy->isVectorType()) 1826198092Srdivacky return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 1827198092Srdivacky 1828193326Sed } else { 1829193326Sed // Complex Comparison: can only be an equality comparison. 1830193326Sed CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 1831193326Sed CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 1832198092Srdivacky 1833198092Srdivacky QualType CETy = LHSTy->getAs<ComplexType>()->getElementType(); 1834198092Srdivacky 1835193326Sed Value *ResultR, *ResultI; 1836193326Sed if (CETy->isRealFloatingType()) { 1837193326Sed ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 1838193326Sed LHS.first, RHS.first, "cmp.r"); 1839193326Sed ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 1840193326Sed LHS.second, RHS.second, "cmp.i"); 1841193326Sed } else { 1842193326Sed // Complex comparisons can only be equality comparisons. As such, signed 1843193326Sed // and unsigned opcodes are the same. 1844193326Sed ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1845193326Sed LHS.first, RHS.first, "cmp.r"); 1846193326Sed ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1847193326Sed LHS.second, RHS.second, "cmp.i"); 1848193326Sed } 1849198092Srdivacky 1850212904Sdim if (E->getOpcode() == BO_EQ) { 1851193326Sed Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 1852193326Sed } else { 1853212904Sdim assert(E->getOpcode() == BO_NE && 1854193326Sed "Complex comparison other than == or != ?"); 1855193326Sed Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 1856193326Sed } 1857193326Sed } 1858193326Sed 1859193326Sed return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 1860193326Sed} 1861193326Sed 1862193326SedValue *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 1863193326Sed bool Ignore = TestAndClearIgnoreResultAssign(); 1864193326Sed 1865193326Sed // __block variables need to have the rhs evaluated first, plus this should 1866193326Sed // improve codegen just a little. 1867193326Sed Value *RHS = Visit(E->getRHS()); 1868201361Srdivacky LValue LHS = EmitCheckedLValue(E->getLHS()); 1869198092Srdivacky 1870193326Sed // Store the value into the LHS. Bit-fields are handled specially 1871193326Sed // because the result is altered by the store, i.e., [C99 6.5.16p1] 1872193326Sed // 'An assignment expression has the value of the left operand after 1873193326Sed // the assignment...'. 1874210299Sed if (LHS.isBitField()) 1875210299Sed CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType(), 1876210299Sed &RHS); 1877210299Sed else 1878193326Sed CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType()); 1879210299Sed 1880210299Sed // If the result is clearly ignored, return now. 1881193326Sed if (Ignore) 1882193326Sed return 0; 1883210299Sed 1884210299Sed // Objective-C property assignment never reloads the value following a store. 1885210299Sed if (LHS.isPropertyRef() || LHS.isKVCRef()) 1886210299Sed return RHS; 1887210299Sed 1888210299Sed // If the lvalue is non-volatile, return the computed value of the assignment. 1889210299Sed if (!LHS.isVolatileQualified()) 1890210299Sed return RHS; 1891210299Sed 1892210299Sed // Otherwise, reload the value. 1893193326Sed return EmitLoadOfLValue(LHS, E->getType()); 1894193326Sed} 1895193326Sed 1896193326SedValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 1897198398Srdivacky const llvm::Type *ResTy = ConvertType(E->getType()); 1898198398Srdivacky 1899193326Sed // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 1900193326Sed // If we have 1 && X, just emit X without inserting the control flow. 1901193326Sed if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 1902193326Sed if (Cond == 1) { // If we have 1 && X, just emit X. 1903193326Sed Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 1904198398Srdivacky // ZExt result to int or bool. 1905198398Srdivacky return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 1906193326Sed } 1907198092Srdivacky 1908198398Srdivacky // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 1909193326Sed if (!CGF.ContainsLabel(E->getRHS())) 1910198398Srdivacky return llvm::Constant::getNullValue(ResTy); 1911193326Sed } 1912198092Srdivacky 1913193326Sed llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 1914193326Sed llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 1915193326Sed 1916193326Sed // Branch on the LHS first. If it is false, go to the failure (cont) block. 1917193326Sed CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 1918193326Sed 1919193326Sed // Any edges into the ContBlock are now from an (indeterminate number of) 1920193326Sed // edges from this first condition. All of these values will be false. Start 1921193326Sed // setting up the PHI node in the Cont Block for this. 1922198092Srdivacky llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 1923198092Srdivacky "", ContBlock); 1924193326Sed PN->reserveOperandSpace(2); // Normal case, two inputs. 1925193326Sed for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 1926193326Sed PI != PE; ++PI) 1927198092Srdivacky PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 1928198092Srdivacky 1929203955Srdivacky CGF.BeginConditionalBranch(); 1930193326Sed CGF.EmitBlock(RHSBlock); 1931193326Sed Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 1932203955Srdivacky CGF.EndConditionalBranch(); 1933198092Srdivacky 1934193326Sed // Reaquire the RHS block, as there may be subblocks inserted. 1935193326Sed RHSBlock = Builder.GetInsertBlock(); 1936193326Sed 1937193326Sed // Emit an unconditional branch from this block to ContBlock. Insert an entry 1938193326Sed // into the phi node for the edge with the value of RHSCond. 1939193326Sed CGF.EmitBlock(ContBlock); 1940193326Sed PN->addIncoming(RHSCond, RHSBlock); 1941198092Srdivacky 1942193326Sed // ZExt result to int. 1943198398Srdivacky return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 1944193326Sed} 1945193326Sed 1946193326SedValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 1947198398Srdivacky const llvm::Type *ResTy = ConvertType(E->getType()); 1948198398Srdivacky 1949193326Sed // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 1950193326Sed // If we have 0 || X, just emit X without inserting the control flow. 1951193326Sed if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 1952193326Sed if (Cond == -1) { // If we have 0 || X, just emit X. 1953193326Sed Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 1954198398Srdivacky // ZExt result to int or bool. 1955198398Srdivacky return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 1956193326Sed } 1957198092Srdivacky 1958198398Srdivacky // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 1959193326Sed if (!CGF.ContainsLabel(E->getRHS())) 1960198398Srdivacky return llvm::ConstantInt::get(ResTy, 1); 1961193326Sed } 1962198092Srdivacky 1963193326Sed llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 1964193326Sed llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 1965198092Srdivacky 1966193326Sed // Branch on the LHS first. If it is true, go to the success (cont) block. 1967193326Sed CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 1968193326Sed 1969193326Sed // Any edges into the ContBlock are now from an (indeterminate number of) 1970193326Sed // edges from this first condition. All of these values will be true. Start 1971193326Sed // setting up the PHI node in the Cont Block for this. 1972198092Srdivacky llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 1973198092Srdivacky "", ContBlock); 1974193326Sed PN->reserveOperandSpace(2); // Normal case, two inputs. 1975193326Sed for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 1976193326Sed PI != PE; ++PI) 1977198092Srdivacky PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 1978193326Sed 1979203955Srdivacky CGF.BeginConditionalBranch(); 1980193576Sed 1981193326Sed // Emit the RHS condition as a bool value. 1982193326Sed CGF.EmitBlock(RHSBlock); 1983193326Sed Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 1984198092Srdivacky 1985203955Srdivacky CGF.EndConditionalBranch(); 1986198092Srdivacky 1987193326Sed // Reaquire the RHS block, as there may be subblocks inserted. 1988193326Sed RHSBlock = Builder.GetInsertBlock(); 1989198092Srdivacky 1990193326Sed // Emit an unconditional branch from this block to ContBlock. Insert an entry 1991193326Sed // into the phi node for the edge with the value of RHSCond. 1992193326Sed CGF.EmitBlock(ContBlock); 1993193326Sed PN->addIncoming(RHSCond, RHSBlock); 1994198092Srdivacky 1995193326Sed // ZExt result to int. 1996198398Srdivacky return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 1997193326Sed} 1998193326Sed 1999193326SedValue *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 2000193326Sed CGF.EmitStmt(E->getLHS()); 2001193326Sed CGF.EnsureInsertPoint(); 2002193326Sed return Visit(E->getRHS()); 2003193326Sed} 2004193326Sed 2005193326Sed//===----------------------------------------------------------------------===// 2006193326Sed// Other Operators 2007193326Sed//===----------------------------------------------------------------------===// 2008193326Sed 2009193326Sed/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 2010193326Sed/// expression is cheap enough and side-effect-free enough to evaluate 2011193326Sed/// unconditionally instead of conditionally. This is used to convert control 2012193326Sed/// flow into selects in some cases. 2013198893Srdivackystatic bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 2014198893Srdivacky CodeGenFunction &CGF) { 2015193326Sed if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) 2016198893Srdivacky return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr(), CGF); 2017198092Srdivacky 2018193326Sed // TODO: Allow anything we can constant fold to an integer or fp constant. 2019193326Sed if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) || 2020193326Sed isa<FloatingLiteral>(E)) 2021193326Sed return true; 2022198092Srdivacky 2023193326Sed // Non-volatile automatic variables too, to get "cond ? X : Y" where 2024193326Sed // X and Y are local variables. 2025193326Sed if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 2026193326Sed if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 2027198893Srdivacky if (VD->hasLocalStorage() && !(CGF.getContext() 2028198893Srdivacky .getCanonicalType(VD->getType()) 2029198893Srdivacky .isVolatileQualified())) 2030193326Sed return true; 2031198092Srdivacky 2032193326Sed return false; 2033193326Sed} 2034193326Sed 2035193326Sed 2036193326SedValue *ScalarExprEmitter:: 2037193326SedVisitConditionalOperator(const ConditionalOperator *E) { 2038193326Sed TestAndClearIgnoreResultAssign(); 2039193326Sed // If the condition constant folds and can be elided, try to avoid emitting 2040193326Sed // the condition and the dead arm. 2041193326Sed if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getCond())){ 2042193326Sed Expr *Live = E->getLHS(), *Dead = E->getRHS(); 2043193326Sed if (Cond == -1) 2044193326Sed std::swap(Live, Dead); 2045198092Srdivacky 2046193326Sed // If the dead side doesn't have labels we need, and if the Live side isn't 2047193326Sed // the gnu missing ?: extension (which we could handle, but don't bother 2048193326Sed // to), just emit the Live part. 2049193326Sed if ((!Dead || !CGF.ContainsLabel(Dead)) && // No labels in dead part 2050193326Sed Live) // Live part isn't missing. 2051193326Sed return Visit(Live); 2052193326Sed } 2053198092Srdivacky 2054198092Srdivacky 2055193326Sed // If this is a really simple expression (like x ? 4 : 5), emit this as a 2056193326Sed // select instead of as control flow. We can only do this if it is cheap and 2057193326Sed // safe to evaluate the LHS and RHS unconditionally. 2058198893Srdivacky if (E->getLHS() && isCheapEnoughToEvaluateUnconditionally(E->getLHS(), 2059198893Srdivacky CGF) && 2060198893Srdivacky isCheapEnoughToEvaluateUnconditionally(E->getRHS(), CGF)) { 2061193326Sed llvm::Value *CondV = CGF.EvaluateExprAsBool(E->getCond()); 2062193326Sed llvm::Value *LHS = Visit(E->getLHS()); 2063193326Sed llvm::Value *RHS = Visit(E->getRHS()); 2064193326Sed return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 2065193326Sed } 2066198092Srdivacky 2067212904Sdim if (!E->getLHS() && CGF.getContext().getLangOptions().CPlusPlus) { 2068212904Sdim // Does not support GNU missing condition extension in C++ yet (see #7726) 2069212904Sdim CGF.ErrorUnsupported(E, "conditional operator with missing LHS"); 2070212904Sdim return llvm::UndefValue::get(ConvertType(E->getType())); 2071212904Sdim } 2072212904Sdim 2073193326Sed llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 2074193326Sed llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 2075193326Sed llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 2076193326Sed Value *CondVal = 0; 2077193326Sed 2078198092Srdivacky // If we don't have the GNU missing condition extension, emit a branch on bool 2079198092Srdivacky // the normal way. 2080193326Sed if (E->getLHS()) { 2081193326Sed // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for 2082193326Sed // the branch on bool. 2083193326Sed CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 2084193326Sed } else { 2085193326Sed // Otherwise, for the ?: extension, evaluate the conditional and then 2086193326Sed // convert it to bool the hard way. We do this explicitly because we need 2087193326Sed // the unconverted value for the missing middle value of the ?:. 2088193326Sed CondVal = CGF.EmitScalarExpr(E->getCond()); 2089198092Srdivacky 2090193326Sed // In some cases, EmitScalarConversion will delete the "CondVal" expression 2091193326Sed // if there are no extra uses (an optimization). Inhibit this by making an 2092193326Sed // extra dead use, because we're going to add a use of CondVal later. We 2093193326Sed // don't use the builder for this, because we don't want it to get optimized 2094193326Sed // away. This leaves dead code, but the ?: extension isn't common. 2095193326Sed new llvm::BitCastInst(CondVal, CondVal->getType(), "dummy?:holder", 2096193326Sed Builder.GetInsertBlock()); 2097198092Srdivacky 2098193326Sed Value *CondBoolVal = 2099193326Sed CGF.EmitScalarConversion(CondVal, E->getCond()->getType(), 2100193326Sed CGF.getContext().BoolTy); 2101193326Sed Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock); 2102193326Sed } 2103193576Sed 2104203955Srdivacky CGF.BeginConditionalBranch(); 2105193326Sed CGF.EmitBlock(LHSBlock); 2106198092Srdivacky 2107193326Sed // Handle the GNU extension for missing LHS. 2108193326Sed Value *LHS; 2109193326Sed if (E->getLHS()) 2110193326Sed LHS = Visit(E->getLHS()); 2111193326Sed else // Perform promotions, to handle cases like "short ?: int" 2112193326Sed LHS = EmitScalarConversion(CondVal, E->getCond()->getType(), E->getType()); 2113198092Srdivacky 2114203955Srdivacky CGF.EndConditionalBranch(); 2115193326Sed LHSBlock = Builder.GetInsertBlock(); 2116193326Sed CGF.EmitBranch(ContBlock); 2117198092Srdivacky 2118203955Srdivacky CGF.BeginConditionalBranch(); 2119193326Sed CGF.EmitBlock(RHSBlock); 2120198092Srdivacky 2121193326Sed Value *RHS = Visit(E->getRHS()); 2122203955Srdivacky CGF.EndConditionalBranch(); 2123193326Sed RHSBlock = Builder.GetInsertBlock(); 2124193326Sed CGF.EmitBranch(ContBlock); 2125198092Srdivacky 2126193326Sed CGF.EmitBlock(ContBlock); 2127198092Srdivacky 2128200583Srdivacky // If the LHS or RHS is a throw expression, it will be legitimately null. 2129200583Srdivacky if (!LHS) 2130200583Srdivacky return RHS; 2131200583Srdivacky if (!RHS) 2132200583Srdivacky return LHS; 2133198092Srdivacky 2134193326Sed // Create a PHI node for the real part. 2135193326Sed llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond"); 2136193326Sed PN->reserveOperandSpace(2); 2137193326Sed PN->addIncoming(LHS, LHSBlock); 2138193326Sed PN->addIncoming(RHS, RHSBlock); 2139193326Sed return PN; 2140193326Sed} 2141193326Sed 2142193326SedValue *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 2143193326Sed return Visit(E->getChosenSubExpr(CGF.getContext())); 2144193326Sed} 2145193326Sed 2146193326SedValue *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 2147193326Sed llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 2148193326Sed llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 2149193326Sed 2150193326Sed // If EmitVAArg fails, we fall back to the LLVM instruction. 2151198092Srdivacky if (!ArgPtr) 2152193326Sed return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 2153193326Sed 2154193326Sed // FIXME Volatility. 2155193326Sed return Builder.CreateLoad(ArgPtr); 2156193326Sed} 2157193326Sed 2158193326SedValue *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *BE) { 2159193326Sed return CGF.BuildBlockLiteralTmp(BE); 2160193326Sed} 2161193326Sed 2162193326Sed//===----------------------------------------------------------------------===// 2163193326Sed// Entry Point into this File 2164193326Sed//===----------------------------------------------------------------------===// 2165193326Sed 2166198092Srdivacky/// EmitScalarExpr - Emit the computation of the specified expression of scalar 2167198092Srdivacky/// type, ignoring the result. 2168193326SedValue *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 2169193326Sed assert(E && !hasAggregateLLVMType(E->getType()) && 2170193326Sed "Invalid scalar expression to emit"); 2171198092Srdivacky 2172193326Sed return ScalarExprEmitter(*this, IgnoreResultAssign) 2173193326Sed .Visit(const_cast<Expr*>(E)); 2174193326Sed} 2175193326Sed 2176193326Sed/// EmitScalarConversion - Emit a conversion from the specified type to the 2177193326Sed/// specified destination type, both of which are LLVM scalar types. 2178193326SedValue *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 2179193326Sed QualType DstTy) { 2180193326Sed assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 2181193326Sed "Invalid scalar expression to emit"); 2182193326Sed return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 2183193326Sed} 2184193326Sed 2185198092Srdivacky/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 2186198092Srdivacky/// type to the specified destination type, where the destination type is an 2187198092Srdivacky/// LLVM scalar type. 2188193326SedValue *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 2189193326Sed QualType SrcTy, 2190193326Sed QualType DstTy) { 2191193326Sed assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 2192193326Sed "Invalid complex -> scalar conversion"); 2193193326Sed return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 2194193326Sed DstTy); 2195193326Sed} 2196193326Sed 2197210299Sed 2198210299Sedllvm::Value *CodeGenFunction:: 2199210299SedEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 2200210299Sed bool isInc, bool isPre) { 2201210299Sed return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre); 2202210299Sed} 2203210299Sed 2204200583SrdivackyLValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 2205200583Srdivacky llvm::Value *V; 2206200583Srdivacky // object->isa or (*object).isa 2207200583Srdivacky // Generate code as for: *(Class*)object 2208203955Srdivacky // build Class* type 2209203955Srdivacky const llvm::Type *ClassPtrTy = ConvertType(E->getType()); 2210203955Srdivacky 2211200583Srdivacky Expr *BaseExpr = E->getBase(); 2212203955Srdivacky if (BaseExpr->isLvalue(getContext()) != Expr::LV_Valid) { 2213203955Srdivacky V = CreateTempAlloca(ClassPtrTy, "resval"); 2214203955Srdivacky llvm::Value *Src = EmitScalarExpr(BaseExpr); 2215203955Srdivacky Builder.CreateStore(Src, V); 2216212904Sdim V = ScalarExprEmitter(*this).EmitLoadOfLValue( 2217212904Sdim MakeAddrLValue(V, E->getType()), E->getType()); 2218212904Sdim } else { 2219212904Sdim if (E->isArrow()) 2220212904Sdim V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr); 2221212904Sdim else 2222212904Sdim V = EmitLValue(BaseExpr).getAddress(); 2223203955Srdivacky } 2224200583Srdivacky 2225200583Srdivacky // build Class* type 2226200583Srdivacky ClassPtrTy = ClassPtrTy->getPointerTo(); 2227200583Srdivacky V = Builder.CreateBitCast(V, ClassPtrTy); 2228212904Sdim return MakeAddrLValue(V, E->getType()); 2229200583Srdivacky} 2230200583Srdivacky 2231207619Srdivacky 2232207619SrdivackyLValue CodeGenFunction::EmitCompoundAssignOperatorLValue( 2233207619Srdivacky const CompoundAssignOperator *E) { 2234207619Srdivacky ScalarExprEmitter Scalar(*this); 2235210299Sed Value *Result = 0; 2236207619Srdivacky switch (E->getOpcode()) { 2237207619Srdivacky#define COMPOUND_OP(Op) \ 2238212904Sdim case BO_##Op##Assign: \ 2239207619Srdivacky return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 2240210299Sed Result) 2241207619Srdivacky COMPOUND_OP(Mul); 2242207619Srdivacky COMPOUND_OP(Div); 2243207619Srdivacky COMPOUND_OP(Rem); 2244207619Srdivacky COMPOUND_OP(Add); 2245207619Srdivacky COMPOUND_OP(Sub); 2246207619Srdivacky COMPOUND_OP(Shl); 2247207619Srdivacky COMPOUND_OP(Shr); 2248207619Srdivacky COMPOUND_OP(And); 2249207619Srdivacky COMPOUND_OP(Xor); 2250207619Srdivacky COMPOUND_OP(Or); 2251207619Srdivacky#undef COMPOUND_OP 2252207619Srdivacky 2253212904Sdim case BO_PtrMemD: 2254212904Sdim case BO_PtrMemI: 2255212904Sdim case BO_Mul: 2256212904Sdim case BO_Div: 2257212904Sdim case BO_Rem: 2258212904Sdim case BO_Add: 2259212904Sdim case BO_Sub: 2260212904Sdim case BO_Shl: 2261212904Sdim case BO_Shr: 2262212904Sdim case BO_LT: 2263212904Sdim case BO_GT: 2264212904Sdim case BO_LE: 2265212904Sdim case BO_GE: 2266212904Sdim case BO_EQ: 2267212904Sdim case BO_NE: 2268212904Sdim case BO_And: 2269212904Sdim case BO_Xor: 2270212904Sdim case BO_Or: 2271212904Sdim case BO_LAnd: 2272212904Sdim case BO_LOr: 2273212904Sdim case BO_Assign: 2274212904Sdim case BO_Comma: 2275207619Srdivacky assert(false && "Not valid compound assignment operators"); 2276207619Srdivacky break; 2277207619Srdivacky } 2278207619Srdivacky 2279207619Srdivacky llvm_unreachable("Unhandled compound assignment operator"); 2280207619Srdivacky} 2281