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