CGExprScalar.cpp revision 569c3166874324c24011f8ade6978421f0d39b3c
17f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===// 27f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 37f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// The LLVM Compiler Infrastructure 47f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 77f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 87f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 97f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// This contains code to emit Expr nodes with scalar LLVM types as LLVM code. 117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "CodeGenFunction.h" 15f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian#include "CGObjCRuntime.h" 167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "CodeGenModule.h" 17de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 1898c5ead87d720d8b68b6f236c3c3579a388fc882Daniel Dunbar#include "clang/AST/DeclObjC.h" 1919cc4abea06a9b49e0e16a50d335c064cd723572Anders Carlsson#include "clang/AST/RecordLayout.h" 20de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/StmtVisitor.h" 2125ddea7f7835c4b1804e458a5c866cde0097430aChris Lattner#include "clang/Basic/TargetInfo.h" 227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "llvm/Constants.h" 237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "llvm/Function.h" 2485f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson#include "llvm/GlobalVariable.h" 257c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson#include "llvm/Intrinsics.h" 262add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump#include "llvm/Module.h" 27f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner#include "llvm/Support/CFG.h" 284e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump#include "llvm/Target/TargetData.h" 29c89bf69c9289d2b2305f2c267daacc7312391898Chris Lattner#include <cstdarg> 306aad91a43e26118c824d976661077819265d9bc0Ted Kremenek 317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing namespace clang; 327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing namespace CodeGen; 337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing llvm::Value; 347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Scalar Expression Emitter 377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerstruct BinOpInfo { 407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS; 417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS; 421f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner QualType Ty; // Computation Type. 439a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinaryOperator::Opcode Opcode; // Opcode of BinOp to perform 449a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const Expr *E; // Entire expr, for error unsupported. May not be binop. 457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnernamespace { 4885b4521e34dcd4a0a4a1f0819e1123128e5a3125Benjamin Kramerclass ScalarExprEmitter 497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner : public StmtVisitor<ScalarExprEmitter, Value*> { 507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction &CGF; 5145d196b8387dcefc4df26cda114fa34c6528e928Daniel Dunbar CGBuilderTy &Builder; 527f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreResultAssign; 53a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson llvm::LLVMContext &VMContext; 547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerpublic: 557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 567f79f9be5916c51c35da4f126b7c12596a101607Mike Stump ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false) 57db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira), 58a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson VMContext(cgf.getLLVMContext()) { 597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 60db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Utilities 637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 657f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool TestAndClearIgnoreResultAssign() { 669c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner bool I = IgnoreResultAssign; 679c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner IgnoreResultAssign = false; 689c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return I; 699c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner } 707f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); } 727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); } 73b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue EmitCheckedLValue(const Expr *E) { return CGF.EmitCheckedLValue(E); } 747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(LValue LV, QualType T) { 769b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitLoadOfLValue(LV, T).getScalarVal(); 777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 78db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// EmitLoadOfLValue - Given an expression with complex type that represents a 807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// value l-value, this method emits the address of the l-value, then loads 817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// and returns the result. 827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(const Expr *E) { 83b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump return EmitLoadOfLValue(EmitCheckedLValue(E), E->getType()); 847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 85db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 869abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner /// EmitConversionToBool - Convert the specified expression value to a 873420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner /// boolean (i1) truth value. This is equivalent to "Val != 0". 889abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner Value *EmitConversionToBool(Value *Src, QualType DstTy); 89db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 903707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// EmitScalarConversion - Emit a conversion from the specified type to the 913707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// specified destination type, both of which are LLVM scalar types. 924f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy); 934f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 944f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner /// EmitComplexToScalarConversion - Emit a conversion from the specified 95db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump /// complex type to the specified destination type, where the destination type 96db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump /// is an LLVM scalar type. 974f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 984f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy); 99df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 100a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson /// EmitNullValue - Emit a value that corresponds to null for the given type. 101a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson Value *EmitNullValue(QualType Ty); 102a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 1037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 1047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Visitor Methods 1057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 1067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitStmt(Stmt *S) { 1087a9d49fd2bfac00e905b361ba76d26ab5b6c3b09Ted Kremenek S->dump(CGF.getContext().getSourceManager()); 1097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(0 && "Stmt can't have complex result type!"); 1107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 1117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitExpr(Expr *S); 113f51dc64f90851f636302dbaaf3f52c0524cdac36Fariborz Jahanian 1147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr()); } 1157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Leaves. 1177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitIntegerLiteral(const IntegerLiteral *E) { 1184a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(VMContext, E->getValue()); 1197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitFloatingLiteral(const FloatingLiteral *E) { 121bc0a2226c7fcd18b29b6846049e2cfcb872d3593Owen Anderson return llvm::ConstantFP::get(VMContext, E->getValue()); 1227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCharacterLiteral(const CharacterLiteral *E) { 1244a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 125e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman } 126e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 1274a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 1287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 129ed8abf18329df67b0abcbb3a10458bd8c1d2a595Douglas Gregor Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) { 130a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1317267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis } 1323f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson Value *VisitGNUNullExpr(const GNUNullExpr *E) { 133a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1343f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson } 1357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) { 1364a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), 137ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff CGF.getContext().typesAreCompatible( 138ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff E->getArgType1(), E->getArgType2())); 1397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1400027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Value *VisitOffsetOfExpr(OffsetOfExpr *E); 1410518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl Value *VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E); 1420ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar Value *VisitAddrLabelExpr(const AddrLabelExpr *E) { 143d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel()); 144d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return Builder.CreateBitCast(V, ConvertType(E->getType())); 1450ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar } 146db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // l-values. 1487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitDeclRefExpr(DeclRefExpr *E) { 14928665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 15028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 15128665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman assert(!Result.HasSideEffects && "Constant declref with side-effect?!"); 15228665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 15328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 1547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 1557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 156db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 157db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCSelectorExpr(E); 1589c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 159db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 160db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCProtocolExpr(E); 1619c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 162db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 1639c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return EmitLoadOfLValue(E); 1649c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 1650a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 16685c59edda02df48fae8dc85049743319bc6e7e89Daniel Dunbar return EmitLoadOfLValue(E); 1679c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 16809105f52b1f28cbb1374c27c3c70f5517e2c465dFariborz Jahanian Value *VisitObjCImplicitSetterGetterRefExpr( 16909105f52b1f28cbb1374c27c3c70f5517e2c465dFariborz Jahanian ObjCImplicitSetterGetterRefExpr *E) { 17043f447098d5e6162fbfb97ed38365284207a7fbeFariborz Jahanian return EmitLoadOfLValue(E); 17143f447098d5e6162fbfb97ed38365284207a7fbeFariborz Jahanian } 1729c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar Value *VisitObjCMessageExpr(ObjCMessageExpr *E) { 1739c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return CGF.EmitObjCMessageExpr(E).getScalarVal(); 1740a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar } 1750a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar 17683dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian Value *VisitObjCIsaExpr(ObjCIsaExpr *E) { 177820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian LValue LV = CGF.EmitObjCIsaExpr(E); 178820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Value *V = CGF.EmitLoadOfLValue(LV, E->getType()).getScalarVal(); 17983dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian return V; 18083dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian } 18183dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian 1827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 183d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E); 18428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Value *VisitMemberExpr(MemberExpr *E); 185213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); } 186be20bb558cae5352898e6a913e29d24d20134841Chris Lattner Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 187be20bb558cae5352898e6a913e29d24d20134841Chris Lattner return EmitLoadOfLValue(E); 188be20bb558cae5352898e6a913e29d24d20134841Chris Lattner } 18935634f5ed67966c9f1fde38420e79cc6515cd673Devang Patel 1900533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *VisitInitListExpr(InitListExpr *E); 191db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1923498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) { 1933cb18bcefe39756f3b079fa1a62b4c9cbf6a592fAnders Carlsson return CGF.CGM.EmitNullConstant(E->getType()); 1943498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor } 195d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *VisitCastExpr(CastExpr *E) { 196c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman // Make sure to evaluate VLA bounds now so that we have them for later. 197c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman if (E->getType()->isVariablyModifiedType()) 198c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman CGF.EmitVLASize(E->getType()); 199c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman 200592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson return EmitCastExpr(E); 2017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 202d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *EmitCastExpr(CastExpr *E); 2037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCallExpr(const CallExpr *E) { 205e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson if (E->getCallReturnType()->isReferenceType()) 206e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson return EmitLoadOfLValue(E); 207db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2089b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitCallExpr(E).getScalarVal(); 2097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2108f2926b73ed635afecd020da787af6a837601a2bDaniel Dunbar 2113379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner Value *VisitStmtExpr(const StmtExpr *E); 2124e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump 213a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike Stump Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E); 214db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Unary Operators. 2167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostDec(const UnaryOperator *E) { 2178c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2188c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, false); 2197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostInc(const UnaryOperator *E) { 2218c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2228c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, false); 2237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreDec(const UnaryOperator *E) { 2258c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2268c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, true); 2277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreInc(const UnaryOperator *E) { 2298c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2308c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, true); 2317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2328c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2338c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 2348c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre); 2358c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2368c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryAddrOf(const UnaryOperator *E) { 2387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLValue(E->getSubExpr()).getAddress(); 2397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 2417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPlus(const UnaryOperator *E) { 2427f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // This differs from gcc, though, most likely due to a bug in gcc. 2437f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 2447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 2457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryMinus (const UnaryOperator *E); 2477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryNot (const UnaryOperator *E); 2487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryLNot (const UnaryOperator *E); 24946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryReal (const UnaryOperator *E); 25046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryImag (const UnaryOperator *E); 2517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryExtension(const UnaryOperator *E) { 2527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 2537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2545a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson Value *VisitUnaryOffsetOf(const UnaryOperator *E); 2558ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 2565f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson // C++ 25704421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 25804421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 25904421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 2605f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson Value *VisitCXXThisExpr(CXXThisExpr *TE) { 2615f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson return CGF.LoadCXXThis(); 262db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 263db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2647f6ad153565245026c7569314f65a4d4ff4ac41fAnders Carlsson Value *VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { 2653082463f4f387b725f4e4bf7d7b46269d445e4f5Anders Carlsson return CGF.EmitCXXExprWithTemporaries(E).getScalarVal(); 2667f6ad153565245026c7569314f65a4d4ff4ac41fAnders Carlsson } 267a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson Value *VisitCXXNewExpr(const CXXNewExpr *E) { 268a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson return CGF.EmitCXXNewExpr(E); 269a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson } 27060e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) { 27160e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson CGF.EmitCXXDeleteExpr(E); 27260e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson return 0; 27360e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson } 2749dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman Value *VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 2759dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman return llvm::ConstantInt::get(Builder.getInt1Ty(), 2769dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman E->EvaluateTrait(CGF.getContext())); 2779dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman } 278db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 279a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) { 280a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // C++ [expr.pseudo]p1: 281db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // The result shall only be used as the operand for the function call 282a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // operator (), and the result of such a call has type void. The only 283a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // effect is the evaluation of the postfix-expression before the dot or 284a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // arrow. 285a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor CGF.EmitScalarExpr(E->getBase()); 286a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor return 0; 287a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor } 288db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 289c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 290a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 291c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson } 292756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 293756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson Value *VisitCXXThrowExpr(const CXXThrowExpr *E) { 294756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson CGF.EmitCXXThrowExpr(E); 295756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson return 0; 296756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson } 297756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 2987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Binary Operators. 2997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitMul(const BinOpInfo &Ops) { 300f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 301a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 302a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 303a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul"); 304a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 305a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 306a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 307a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 308a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 309a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 310a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 311f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 31287415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul"); 3137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 3147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3152add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Create a binary op that checks for overflow. 3162add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Currently only supports +, - and *. 3172add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); 3187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitDiv(const BinOpInfo &Ops); 3197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitRem(const BinOpInfo &Ops); 3207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAdd(const BinOpInfo &Ops); 3217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitSub(const BinOpInfo &Ops); 3227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShl(const BinOpInfo &Ops); 3237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShr(const BinOpInfo &Ops); 3247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAnd(const BinOpInfo &Ops) { 3257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 3267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitXor(const BinOpInfo &Ops) { 3287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 3297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitOr (const BinOpInfo &Ops) { 3317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 3327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3341f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo EmitBinOps(const BinaryOperator *E); 3356a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 3366a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*F)(const BinOpInfo &), 337d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result); 3386a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 3393ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *EmitCompoundAssign(const CompoundAssignOperator *E, 3401f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 3411f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 3421f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Binary operators and binary compound assignment operators. 3431f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#define HANDLEBINOP(OP) \ 3443ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP(const BinaryOperator *E) { \ 3453ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return Emit ## OP(EmitBinOps(E)); \ 3463ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner } \ 3473ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 3483ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 3491f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 3507177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Mul) 3517177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Div) 3527177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Rem) 3537177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Add) 3547177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Sub) 3557177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shl) 3567177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shr) 3577177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(And) 3587177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Xor) 3597177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Or) 3601f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#undef HANDLEBINOP 3618c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 3627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Comparisons. 3637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 3647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc); 3657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#define VISITCOMP(CODE, UI, SI, FP) \ 3667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBin##CODE(const BinaryOperator *E) { \ 3677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 3687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::FCmpInst::FP); } 3697177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT) 3707177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT) 3717177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE) 3727177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE) 3737177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ) 3747177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE) 3757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#undef VISITCOMP 376db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinAssign (const BinaryOperator *E); 3787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLAnd (const BinaryOperator *E); 3807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLOr (const BinaryOperator *E); 3817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinComma (const BinaryOperator *E); 3827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 38325b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); } 38425b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); } 38525b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman 3867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Other Operators. 387df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump Value *VisitBlockExpr(const BlockExpr *BE); 3887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitConditionalOperator(const ConditionalOperator *CO); 3897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitChooseExpr(ChooseExpr *CE); 3907c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson Value *VisitVAArgExpr(VAArgExpr *VE); 3917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 3927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return CGF.EmitObjCStringLiteral(E); 3937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 3957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} // end anonymous namespace. 3967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 3987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Utilities 3997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 4007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4019abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner/// EmitConversionToBool - Convert the specified expression value to a 4023420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner/// boolean (i1) truth value. This is equivalent to "Val != 0". 4039abc84e7ac4db891209fe67cc3a8c9690dc886efChris LattnerValue *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 404467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs"); 405db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4069abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner if (SrcType->isRealFloatingType()) { 4079abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Compare against 0.0 for fp scalars. 408c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 4099abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Builder.CreateFCmpUNE(Src, Zero, "tobool"); 4109abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 411db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 412237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson if (SrcType->isMemberPointerType()) { 413237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson // Compare against -1. 414237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson llvm::Value *NegativeOne = llvm::Constant::getAllOnesValue(Src->getType()); 415237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson return Builder.CreateICmpNE(Src, NegativeOne, "tobool"); 416237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson } 417db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 418d1d66bcd6914ff82abdfa88dd25bb0b74cde3b99Daniel Dunbar assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 4199abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner "Unknown scalar type to convert"); 420db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4219abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Because of the type rules of C, we often end up computing a logical value, 4229abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // then zero extending it to int, then wanting it as a logical value again. 4239abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Optimize this common case. 4249abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(Src)) { 4250032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson if (ZI->getOperand(0)->getType() == 4260032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::Type::getInt1Ty(CGF.getLLVMContext())) { 4279abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner Value *Result = ZI->getOperand(0); 428356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // If there aren't any more uses, zap the instruction to save space. 429356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // Note that there can be more uses, for example if this 430356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // is the result of an assignment. 431356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman if (ZI->use_empty()) 432356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman ZI->eraseFromParent(); 4339abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Result; 4349abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 4359abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 436db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4379abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Compare against an integer or pointer null. 438c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 4399abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Builder.CreateICmpNE(Src, Zero, "tobool"); 4409abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner} 4419abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 4423707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 4433707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 4444f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 4454f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstType) { 4469619662a1d42e2008b865d3459c0677e149dad1bChris Lattner SrcType = CGF.getContext().getCanonicalType(SrcType); 4479619662a1d42e2008b865d3459c0677e149dad1bChris Lattner DstType = CGF.getContext().getCanonicalType(DstType); 4483707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (SrcType == DstType) return Src; 449db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 450cf289083ab007264fa3ea96d92f133339aee5d2dChris Lattner if (DstType->isVoidType()) return 0; 451db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4523707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 453ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstType->isBooleanType()) 454ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return EmitConversionToBool(Src, SrcType); 455db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4563707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner const llvm::Type *DstTy = ConvertType(DstType); 4573707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4583707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Ignore conversions like int -> uint. 4593707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (Src->getType() == DstTy) 4603707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Src; 4613707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 462db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle pointer conversions next: pointers can only be converted to/from 463db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // other pointers and integers. Check for pointer types in terms of LLVM, as 464db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // some native types (like Obj-C id) may map to a pointer type. 465270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(DstTy)) { 4663707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // The source value may be an integer, or a pointer. 467191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson if (isa<llvm::PointerType>(Src->getType())) 4683707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Builder.CreateBitCast(Src, DstTy, "conv"); 469191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 4703707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 47125615424741bcce31fe52c896f76268f0307f00dEli Friedman // First, convert to the correct width so that we control the kind of 47225615424741bcce31fe52c896f76268f0307f00dEli Friedman // extension. 47377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 47425615424741bcce31fe52c896f76268f0307f00dEli Friedman bool InputSigned = SrcType->isSignedIntegerType(); 47525615424741bcce31fe52c896f76268f0307f00dEli Friedman llvm::Value* IntResult = 47625615424741bcce31fe52c896f76268f0307f00dEli Friedman Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 47725615424741bcce31fe52c896f76268f0307f00dEli Friedman // Then, cast to pointer. 47825615424741bcce31fe52c896f76268f0307f00dEli Friedman return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 4793707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 480db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 481270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(Src->getType())) { 4823707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Must be an ptr to int cast. 4833707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 48450b5a30db40322880340e957ad7d6d8d60bb4c5bAnders Carlsson return Builder.CreatePtrToInt(Src, DstTy, "conv"); 4853707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 486db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 487213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // A scalar can be splatted to an extended vector of the same element type 4882ef13e5abef0570a9f567b4671367275c05d4d34Nate Begeman if (DstType->isExtVectorType() && !SrcType->isVectorType()) { 4896fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Cast the scalar to element type 490183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType EltTy = DstType->getAs<ExtVectorType>()->getElementType(); 4916fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 4926fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 4936fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Insert the element in element zero of an undef vector 49403e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::Value *UnV = llvm::UndefValue::get(DstTy); 49577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 4966fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 4976fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 4986fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Splat the element across to all elements 4996fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 5006fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 5016fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman for (unsigned i = 0; i < NumElements; i++) 50277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 0)); 503db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5044a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 5056fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 5066fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman return Yay; 5076fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman } 5084119d1aeca8016654d381ce079864058d1709571Nate Begeman 5093b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner // Allow bitcast from vector to integer/fp of the same size. 5107019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson if (isa<llvm::VectorType>(Src->getType()) || 5113b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner isa<llvm::VectorType>(DstTy)) 5127019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson return Builder.CreateBitCast(Src, DstTy, "conv"); 513db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5143707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Finally, we have the arithmetic types: real int/float. 5153707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(Src->getType())) { 5163707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner bool InputSigned = SrcType->isSignedIntegerType(); 517b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (isa<llvm::IntegerType>(DstTy)) 518b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 519b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else if (InputSigned) 520b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateSIToFP(Src, DstTy, "conv"); 521b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 522b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateUIToFP(Src, DstTy, "conv"); 5233707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 524db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 525f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(Src->getType()->isFloatingPointTy() && "Unknown real conversion"); 5263707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(DstTy)) { 527b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstType->isSignedIntegerType()) 528b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToSI(Src, DstTy, "conv"); 529b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 530b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToUI(Src, DstTy, "conv"); 5313707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 5323707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 533f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(DstTy->isFloatingPointTy() && "Unknown real conversion"); 534b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstTy->getTypeID() < Src->getType()->getTypeID()) 535b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPTrunc(Src, DstTy, "conv"); 536b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 537b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPExt(Src, DstTy, "conv"); 5383707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 5393707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 540db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 541db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 542db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 5434f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter:: 5444f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerEmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 5454f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy) { 546ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Get the source element type. 547183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall SrcTy = SrcTy->getAs<ComplexType>()->getElementType(); 548db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 549ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 550ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstTy->isBooleanType()) { 551ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Complex != 0 -> (Real != 0) | (Imag != 0) 552ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 553ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 554ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return Builder.CreateOr(Src.first, Src.second, "tobool"); 555ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner } 556db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5574f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 5584f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // the imaginary part of the complex value is discarded and the value of the 5594f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // real part is converted according to the conversion rules for the 560db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // corresponding real type. 5614f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return EmitScalarConversion(Src.first, SrcTy, DstTy); 5624f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 5634f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 564a40a9f31218c743e366322e34b59f0d4d4414198Anders CarlssonValue *ScalarExprEmitter::EmitNullValue(QualType Ty) { 565a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson const llvm::Type *LTy = ConvertType(Ty); 566a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 567a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson if (!Ty->isMemberPointerType()) 568a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return llvm::Constant::getNullValue(LTy); 569a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 570a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson assert(!Ty->isMemberFunctionPointerType() && 571a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson "member function pointers are not scalar!"); 572a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 573a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson // Itanium C++ ABI 2.3: 574a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson // A NULL pointer is represented as -1. 575a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return llvm::ConstantInt::get(LTy, -1ULL, /*isSigned=*/true); 576a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson} 5774f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 5787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Visitor Methods 5807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitExpr(Expr *E) { 583488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGF.ErrorUnsupported(E, "scalar expression"); 5847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getType()->isVoidType()) 5857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 58603e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 5877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 5887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 589d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanValue *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 59037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Vector Mask Case 59137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 2 || 5923f4cb120fe574f7b80864f52a1999502a4f3a83dRafael Espindola (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { 59377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *LHS = CGF.EmitScalarExpr(E->getExpr(0)); 59477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *RHS = CGF.EmitScalarExpr(E->getExpr(1)); 59577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Mask; 59637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 59737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType()); 59837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman unsigned LHSElts = LTy->getNumElements(); 59937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 60037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 3) { 60137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = CGF.EmitScalarExpr(E->getExpr(2)); 60237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 60337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Shuffle LHS & RHS into one input vector. 60437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> concat; 60537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0; i != LHSElts; ++i) { 60677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i)); 60777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i+1)); 60837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 60937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 61037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* CV = llvm::ConstantVector::get(concat.begin(), concat.size()); 61137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); 61237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHSElts *= 2; 61337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } else { 61437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = RHS; 61537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 61637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 61737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType()); 61837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant* EltMask; 61937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 62037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Treat vec3 like vec4. 62137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) 62237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 62337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+2))-1); 62437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else if ((LHSElts == 3) && (E->getNumSubExprs() == 2)) 62537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 62637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+1))-1); 62737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else 62837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 62937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts))-1); 63037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 63137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Mask off the high bits of each shuffle index. 63237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant *, 32> MaskV; 63337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) 63437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MaskV.push_back(EltMask); 63537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 63637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* MaskBits = llvm::ConstantVector::get(MaskV.begin(), MaskV.size()); 63737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); 63837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 63937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = undef 64037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // mask = mask & maskbits 64137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // for each elt 64237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // n = extract mask i 64337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // x = extract val n 64437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = insert newv, x, i 64537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(), 64637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MTy->getNumElements()); 64737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* NewV = llvm::UndefValue::get(RTy); 64837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) { 64977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Indx = llvm::ConstantInt::get(CGF.Int32Ty, i); 65037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateExtractElement(Mask, Indx, "shuf_idx"); 65177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext"); 65237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 65337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 65437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { 65537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *cmpIndx, *newIndx; 65677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner cmpIndx = Builder.CreateICmpUGT(Indx, 65777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(CGF.Int32Ty, 3), 65837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "cmp_shuf_idx"); 65977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner newIndx = Builder.CreateSub(Indx, llvm::ConstantInt::get(CGF.Int32Ty,1), 66037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "shuf_idx_adj"); 66137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx"); 66237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 66337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt"); 66437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman NewV = Builder.CreateInsertElement(NewV, VExt, Indx, "shuf_ins"); 66537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 66637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman return NewV; 667d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 66837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 669d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 670d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 67137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 67237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 67337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> indices; 67437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 67537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant *C = cast<llvm::Constant>(CGF.EmitScalarExpr(E->getExpr(i))); 67637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *VTy = cast<llvm::VectorType>(V1->getType()); 67737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (VTy->getNumElements() == 3) { 67837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C)) { 67937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman uint64_t cVal = CI->getZExtValue(); 68037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (cVal > 3) { 68137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman C = llvm::ConstantInt::get(C->getType(), cVal-1); 68237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 68337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 68437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 68537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman indices.push_back(C); 68637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 68737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 6884a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson Value* SV = llvm::ConstantVector::get(indices.begin(), indices.size()); 689d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 690d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 69128665272c36cccb1014a6ea1217354b0519e2b59Eli FriedmanValue *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) { 69228665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 69328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 69428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->isArrow()) 69528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman CGF.EmitScalarExpr(E->getBase()); 69628665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman else 69728665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman EmitLValue(E->getBase()); 69828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 69928665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 70028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return EmitLoadOfLValue(E); 70128665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman} 702d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 7037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 7047f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 7057f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 7067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Emit subscript expressions in rvalue context's. For most cases, this just 7077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // loads the lvalue formed by the subscript expr. However, we have to be 7087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // careful, because the base of a vector subscript is occasionally an rvalue, 7097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // so we can't get it as an lvalue. 7107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (!E->getBase()->getType()->isVectorType()) 7117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 712db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 7137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the vector case. The base must be a vector, the index must be an 7147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // integer value. 7157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Base = Visit(E->getBase()); 7167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Idx = Visit(E->getIdx()); 717daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman bool IdxSigned = E->getIdx()->getType()->isSignedIntegerType(); 71877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast"); 7197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateExtractElement(Base, Idx, "vecext"); 7207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 7217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7220533b3020ca39898751d4200feed776861dcd1ceNate Begemanstatic llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, 7230533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned Off, const llvm::Type *I32Ty) { 7240533b3020ca39898751d4200feed776861dcd1ceNate Begeman int MV = SVI->getMaskValue(Idx); 7250533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (MV == -1) 7260533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::UndefValue::get(I32Ty); 7270533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::ConstantInt::get(I32Ty, Off+MV); 7280533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 7290533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7300533b3020ca39898751d4200feed776861dcd1ceNate BegemanValue *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { 7310533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool Ignore = TestAndClearIgnoreResultAssign(); 7320533b3020ca39898751d4200feed776861dcd1ceNate Begeman (void)Ignore; 7330533b3020ca39898751d4200feed776861dcd1ceNate Begeman assert (Ignore == false && "init list ignored"); 7340533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned NumInitElements = E->getNumInits(); 7350533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7360533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (E->hadArrayRangeDesignator()) 7370533b3020ca39898751d4200feed776861dcd1ceNate Begeman CGF.ErrorUnsupported(E, "GNU array range designator extension"); 7380533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7390533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VType = 7400533b3020ca39898751d4200feed776861dcd1ceNate Begeman dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 7410533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7420533b3020ca39898751d4200feed776861dcd1ceNate Begeman // We have a scalar in braces. Just use the first element. 7430533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VType) 7440533b3020ca39898751d4200feed776861dcd1ceNate Begeman return Visit(E->getInit(0)); 7450533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7460533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned ResElts = VType->getNumElements(); 7470533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7480533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Loop over initializers collecting the Value for each, and remembering 7490533b3020ca39898751d4200feed776861dcd1ceNate Begeman // whether the source was swizzle (ExtVectorElementExpr). This will allow 7500533b3020ca39898751d4200feed776861dcd1ceNate Begeman // us to fold the shuffle for the swizzle into the shuffle for the vector 7510533b3020ca39898751d4200feed776861dcd1ceNate Begeman // initializer, since LLVM optimizers generally do not want to touch 7520533b3020ca39898751d4200feed776861dcd1ceNate Begeman // shuffles. 7530533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned CurIdx = 0; 7540533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool VIsUndefShuffle = false; 7550533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *V = llvm::UndefValue::get(VType); 7560533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned i = 0; i != NumInitElements; ++i) { 7570533b3020ca39898751d4200feed776861dcd1ceNate Begeman Expr *IE = E->getInit(i); 7580533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Init = Visit(IE); 7590533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 7600533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7610533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType()); 7620533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7630533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Handle scalar elements. If the scalar initializer is actually one 7640533b3020ca39898751d4200feed776861dcd1ceNate Begeman // element of a different vector of the same width, use shuffle instead of 7650533b3020ca39898751d4200feed776861dcd1ceNate Begeman // extract+insert. 7660533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VVT) { 7670533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 7680533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init); 7690533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7700533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (EI->getVectorOperandType()->getNumElements() == ResElts) { 7710533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand()); 7720533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *LHS = 0, *RHS = 0; 7730533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) { 7740533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undef -> shuffle (src, undef) 7750533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(C); 7760533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 1; j != ResElts; ++j) 77777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 7780533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7790533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = EI->getVectorOperand(); 7800533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = V; 7810533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = true; 7820533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else if (VIsUndefShuffle) { 7830533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undefshuffle && size match -> shuffle (v, src) 7840533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V); 7850533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 78677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty)); 78777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 7880533b3020ca39898751d4200feed776861dcd1ceNate Begeman ResElts + C->getZExtValue())); 7890533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + 1; j != ResElts; ++j) 79077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 7910533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7920533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 7930533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = EI->getVectorOperand(); 7940533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 7950533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 7960533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!Args.empty()) { 7970533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 7980533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(LHS, RHS, Mask); 7990533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8000533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8010533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8020533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8030533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 80477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 8050533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 8060533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8070533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8080533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8090533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8100533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8110533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned InitElts = VVT->getNumElements(); 8120533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8130533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's 8140533b3020ca39898751d4200feed776861dcd1ceNate Begeman // input is the same width as the vector being constructed, generate an 8150533b3020ca39898751d4200feed776861dcd1ceNate Begeman // optimized shuffle of the swizzle input into the result. 816a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman unsigned Offset = (CurIdx == 0) ? 0 : ResElts; 8170533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 8180533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init); 8190533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *SVOp = SVI->getOperand(0); 8200533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType()); 8210533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8220533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (OpTy->getNumElements() == ResElts) { 8230533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) { 8240533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the current vector initializer is a shuffle with undef, merge 8250533b3020ca39898751d4200feed776861dcd1ceNate Begeman // this shuffle directly into it. 8260533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) { 8270533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0, 82877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner CGF.Int32Ty)); 8290533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else { 83077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 8310533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8320533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8330533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0, je = InitElts; j != je; ++j) 83477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty)); 8350533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 83677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8370533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8380533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) 8390533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 8400533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8410533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = SVOp; 8420533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8430533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8440533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8450533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Extend init to result vector length, and then shuffle its contribution 8460533b3020ca39898751d4200feed776861dcd1ceNate Begeman // to the vector initializer into V. 8470533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (Args.empty()) { 8480533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 84977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 8500533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = InitElts; j != ResElts; ++j) 85177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8520533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 8530533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), 854a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman Mask, "vext"); 8550533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8560533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.clear(); 8570533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 85877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 8590533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 86077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j+Offset)); 8610533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 86277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8630533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8640533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8650533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If V is undef, make sure it ends up on the RHS of the shuffle to aid 8660533b3020ca39898751d4200feed776861dcd1ceNate Begeman // merging subsequent shuffles into this one. 8670533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) 8680533b3020ca39898751d4200feed776861dcd1ceNate Begeman std::swap(V, Init); 8690533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 8700533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit"); 8710533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = isa<llvm::UndefValue>(Init); 8720533b3020ca39898751d4200feed776861dcd1ceNate Begeman CurIdx += InitElts; 8730533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8740533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8750533b3020ca39898751d4200feed776861dcd1ceNate Begeman // FIXME: evaluate codegen vs. shuffling against constant null vector. 8760533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers. 8770533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::Type *EltTy = VType->getElementType(); 8780533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8790533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers 8800533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { 88177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 8820533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *Init = llvm::Constant::getNullValue(EltTy); 8830533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 8840533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8850533b3020ca39898751d4200feed776861dcd1ceNate Begeman return V; 8860533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 8870533b3020ca39898751d4200feed776861dcd1ceNate Begeman 888a3697c9c155bda93fd2802f37084b620f4738822Anders Carlssonstatic bool ShouldNullCheckClassCastValue(const CastExpr *CE) { 889a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const Expr *E = CE->getSubExpr(); 89023cba801e11b03929c44f8cf54578305963a3476John McCall 89123cba801e11b03929c44f8cf54578305963a3476John McCall if (CE->getCastKind() == CastExpr::CK_UncheckedDerivedToBase) 89223cba801e11b03929c44f8cf54578305963a3476John McCall return false; 893a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 894a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (isa<CXXThisExpr>(E)) { 895a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // We always assume that 'this' is never null. 896a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 897a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 898a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 899a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) { 900906082edf2aea1c6de2926f93a8d7121e49d2a54Sebastian Redl // And that glvalue casts are never null. 901906082edf2aea1c6de2926f93a8d7121e49d2a54Sebastian Redl if (ICE->getCategory() != ImplicitCastExpr::RValue) 902a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 903a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 904a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 905a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return true; 906a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson} 907a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 908504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 909504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// have to handle a more broad range of conversions than explicit casts, as they 910504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// handle things like function to ptr-to-function decay etc. 911d888962cff03b543fbe9ac6051ec6addf5b993b4Eli FriedmanValue *ScalarExprEmitter::EmitCastExpr(CastExpr *CE) { 912d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Expr *E = CE->getSubExpr(); 913592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson QualType DestTy = CE->getType(); 914592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson CastExpr::CastKind Kind = CE->getCastKind(); 915592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson 916504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson if (!DestTy->isVoidType()) 917504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson TestAndClearIgnoreResultAssign(); 918db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 9198c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // Since almost all cast kinds apply to scalars, this switch doesn't have 9208c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // a default case, so the compiler will warn on a missing case. The cases 9218c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // are in the same order as in the CastKind enum. 922504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson switch (Kind) { 9237f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson case CastExpr::CK_Unknown: 924d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman // FIXME: All casts should have a known kind! 925ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman //assert(0 && "Unknown cast kind!"); 926504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson break; 927ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 928569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor case CastExpr::CK_LValueBitCast: 929569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor case CastExpr::CK_ObjCObjectLValueCast: { 930e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor Value *V = EmitLValue(E).getAddress(); 931e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor V = Builder.CreateBitCast(V, 932e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor ConvertType(CGF.getContext().getPointerType(DestTy))); 933e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor // FIXME: Are the qualifiers correct here? 934e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor return EmitLoadOfLValue(LValue::MakeAddr(V, CGF.MakeQualifiers(DestTy)), 935e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor DestTy); 936e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor } 937e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor 93892ef5d75720c032808181133e4d7c5f82230237eFariborz Jahanian case CastExpr::CK_AnyPointerToObjCPointerCast: 9393b27f1a80e4e433b503efd344c909eeafaa9033cFariborz Jahanian case CastExpr::CK_AnyPointerToBlockPointerCast: 940cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson case CastExpr::CK_BitCast: { 941cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 942cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson return Builder.CreateBitCast(Src, ConvertType(DestTy)); 943cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson } 944ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_NoOp: 9450ddb6f7506d3bffe4e526f877d3ef48e8d942b1dAnders Carlsson case CastExpr::CK_UserDefinedConversion: 946ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Visit(const_cast<Expr*>(E)); 947db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 948a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson case CastExpr::CK_BaseToDerived: { 949a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const CXXRecordDecl *DerivedClassDecl = 950a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson DestTy->getCXXRecordDeclForPointerType(); 951a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 952a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl, 953f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 954a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson ShouldNullCheckClassCastValue(CE)); 955a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 95623cba801e11b03929c44f8cf54578305963a3476John McCall case CastExpr::CK_UncheckedDerivedToBase: 957191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson case CastExpr::CK_DerivedToBase: { 958191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson const RecordType *DerivedClassTy = 959191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson E->getType()->getAs<PointerType>()->getPointeeType()->getAs<RecordType>(); 960191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson CXXRecordDecl *DerivedClassDecl = 961191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 962191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 96334a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, 964f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 96534a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson ShouldNullCheckClassCastValue(CE)); 966191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson } 9678c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_Dynamic: { 9688c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman Value *V = Visit(const_cast<Expr*>(E)); 9698c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE); 9708c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman return CGF.EmitDynamicCast(V, DCE); 9718c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman } 972d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman case CastExpr::CK_ToUnion: 973ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(0 && "Should be unreachable!"); 974ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman break; 975d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 976ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_ArrayToPointerDecay: { 977ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(E->getType()->isArrayType() && 978ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Array to pointer decay must have array source type!"); 979ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 980ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *V = EmitLValue(E).getAddress(); // Bitfields can't be arrays. 981ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 982ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Note that VLA pointers are always decayed, so we don't need to do 983ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // anything here. 984ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman if (!E->getType()->isVariableArrayType()) { 985ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 986ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 987ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman ->getElementType()) && 988ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Expected pointer to array"); 989ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman V = Builder.CreateStructGEP(V, 0, "arraydecay"); 990ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 991ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 992ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return V; 993ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 994ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_FunctionToPointerDecay: 995ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return EmitLValue(E).getAddress(); 996ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 997ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_NullToMemberPointer: 998ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return CGF.CGM.EmitNullConstant(DestTy); 999191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 10008c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_BaseToDerivedMemberPointer: 1001d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman case CastExpr::CK_DerivedToBaseMemberPointer: { 1002d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *Src = Visit(E); 1003d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 1004d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman // See if we need to adjust the pointer. 1005d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman const CXXRecordDecl *BaseDecl = 1006d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman cast<CXXRecordDecl>(E->getType()->getAs<MemberPointerType>()-> 1007d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman getClass()->getAs<RecordType>()->getDecl()); 1008d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman const CXXRecordDecl *DerivedDecl = 1009d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman cast<CXXRecordDecl>(CE->getType()->getAs<MemberPointerType>()-> 1010d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman getClass()->getAs<RecordType>()->getDecl()); 1011d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman if (CE->getCastKind() == CastExpr::CK_DerivedToBaseMemberPointer) 1012d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman std::swap(DerivedDecl, BaseDecl); 1013d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 1014bb7e17b52ffaa4097b4c4d7935746d23539ffe2aAnders Carlsson if (llvm::Constant *Adj = 1015f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CGF.CGM.GetNonVirtualBaseClassOffset(DerivedDecl, 1016f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), 1017f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_end())) { 1018d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman if (CE->getCastKind() == CastExpr::CK_DerivedToBaseMemberPointer) 1019e70ffd631179c15d358838464425e3464cf05a98Chris Lattner Src = Builder.CreateNSWSub(Src, Adj, "adj"); 1020d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman else 1021e70ffd631179c15d358838464425e3464cf05a98Chris Lattner Src = Builder.CreateNSWAdd(Src, Adj, "adj"); 1022d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 1023e70ffd631179c15d358838464425e3464cf05a98Chris Lattner 1024d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return Src; 1025d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 1026d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 10278c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_ConstructorConversion: 1028d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman assert(0 && "Should be unreachable!"); 10298c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman break; 10308c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman 10317f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson case CastExpr::CK_IntegralToPointer: { 10327f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 103382debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson 103482debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // First, convert to the correct width so that we control the kind of 103582debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // extension. 103677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 103782debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson bool InputSigned = E->getType()->isSignedIntegerType(); 103882debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson llvm::Value* IntResult = 103982debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 104082debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson 104182debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy)); 10427f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 10437f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson case CastExpr::CK_PointerToIntegral: { 10447f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 10457f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson return Builder.CreatePtrToInt(Src, ConvertType(DestTy)); 10467f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 1047ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_ToVoid: { 1048569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor if (E->Classify(CGF.getContext()).isGLValue()) 1049569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor CGF.EmitLValue(E); 1050569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor else 1051569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor CGF.EmitAnyExpr(E, 0, false, true); 1052ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return 0; 1053ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1054ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_VectorSplat: { 1055ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman const llvm::Type *DstTy = ConvertType(DestTy); 1056ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *Elt = Visit(const_cast<Expr*>(E)); 1057ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1058ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Insert the element in element zero of an undef vector 1059ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *UnV = llvm::UndefValue::get(DstTy); 106077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 1061ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 1062ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1063ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Splat the element across to all elements 1064ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::SmallVector<llvm::Constant*, 16> Args; 1065ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 1066ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman for (unsigned i = 0; i < NumElements; i++) 106777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 0)); 1068ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1069ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 1070ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 1071ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Yay; 1072ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 10738c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_IntegralCast: 10748c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_IntegralToFloating: 10758c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_FloatingToIntegral: 10768c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_FloatingCast: 1077d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return EmitScalarConversion(Visit(E), E->getType(), DestTy); 1078ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 10793a1737030e3c8d209987325c61dacb8e4a65123bEli Friedman case CastExpr::CK_MemberPointerToBoolean: 10803a1737030e3c8d209987325c61dacb8e4a65123bEli Friedman return CGF.EvaluateExprAsBool(E); 1081e9776247577715ad3a19461769a3488a445a8cbdAnders Carlsson } 1082db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 108358a2e944faa16f1f61439acd2e71b19f50189511Chris Lattner // Handle cases where the source is an non-complex type. 1084db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 108519a1d7c646729eb858b15583e647262a22de3637Chris Lattner if (!CGF.hasAggregateLLVMType(E->getType())) { 10863707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner Value *Src = Visit(const_cast<Expr*>(E)); 10873707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 10883707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Use EmitScalarConversion to perform the conversion. 10893707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return EmitScalarConversion(Src, E->getType(), DestTy); 10903707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 1091db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10929b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (E->getType()->isAnyComplexType()) { 109319a1d7c646729eb858b15583e647262a22de3637Chris Lattner // Handle cases where the source is a complex type. 10947f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreImag = true; 10957f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreImagAssign = true; 10967f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreReal = IgnoreResultAssign; 10977f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreRealAssign = IgnoreResultAssign; 10987f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (DestTy->isBooleanType()) 10997f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreImagAssign = IgnoreImag = false; 11007f79f9be5916c51c35da4f126b7c12596a101607Mike Stump else if (DestTy->isVoidType()) { 11017f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreReal = IgnoreImag = false; 11027f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreRealAssign = IgnoreImagAssign = true; 11037f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } 11047f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CodeGenFunction::ComplexPairTy V 11057f79f9be5916c51c35da4f126b7c12596a101607Mike Stump = CGF.EmitComplexExpr(E, IgnoreReal, IgnoreImag, IgnoreRealAssign, 11067f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreImagAssign); 11077f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitComplexToScalarConversion(V, E->getType(), DestTy); 110819a1d7c646729eb858b15583e647262a22de3637Chris Lattner } 110910b00cfe6422906b223724048b9b2123968d3baaChris Lattner 111019a1d7c646729eb858b15583e647262a22de3637Chris Lattner // Okay, this is a cast from an aggregate. It must be a cast to void. Just 111119a1d7c646729eb858b15583e647262a22de3637Chris Lattner // evaluate the result and return. 11127f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitAggExpr(E, 0, false, true); 111319a1d7c646729eb858b15583e647262a22de3637Chris Lattner return 0; 11147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 11157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11163379320c10001d7e1ee5d7e7142c417f797cfe82Chris LattnerValue *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 111791d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner return CGF.EmitCompoundStmt(*E->getSubStmt(), 111891d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner !E->getType()->isVoidType()).getScalarVal(); 11193379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner} 11203379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 1121a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike StumpValue *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 1122f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian llvm::Value *V = CGF.GetAddrOfBlockDecl(E); 1123f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian if (E->getType().isObjCGCWeak()) 1124f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian return CGF.CGM.getObjCRuntime().EmitObjCWeakRead(CGF, V); 11252da84ff228a231adbd3f6f236b857f752d02959aDaniel Dunbar return Builder.CreateLoad(V, "tmp"); 11264e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump} 11273379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 11287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 11297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Unary Operators 11307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 11317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11328c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *ScalarExprEmitter:: 11338c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 11348c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 11358c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11368c11a65c18ae607b7073e1e451264492d2297726Chris Lattner QualType ValTy = E->getSubExpr()->getType(); 11378c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *InVal = EmitLoadOfLValue(LV, ValTy); 11388c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11398c11a65c18ae607b7073e1e451264492d2297726Chris Lattner int AmountVal = isInc ? 1 : -1; 11408c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11418c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (ValTy->isPointerType() && 11428c11a65c18ae607b7073e1e451264492d2297726Chris Lattner ValTy->getAs<PointerType>()->isVariableArrayType()) { 11438c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // The amount of the addition/subtraction needs to account for the VLA size 11448c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.ErrorUnsupported(E, "VLA pointer inc/dec"); 11458c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 11468c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11478c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *NextVal; 11488c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (const llvm::PointerType *PT = 11498c11a65c18ae607b7073e1e451264492d2297726Chris Lattner dyn_cast<llvm::PointerType>(InVal->getType())) { 115077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Constant *Inc = llvm::ConstantInt::get(CGF.Int32Ty, AmountVal); 11518c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (!isa<llvm::FunctionType>(PT->getElementType())) { 11528c11a65c18ae607b7073e1e451264492d2297726Chris Lattner QualType PTEE = ValTy->getPointeeType(); 11538c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (const ObjCObjectType *OIT = PTEE->getAs<ObjCObjectType>()) { 11548c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Handle interface types, which are not represented with a concrete 11558c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // type. 11568c11a65c18ae607b7073e1e451264492d2297726Chris Lattner int size = CGF.getContext().getTypeSize(OIT) / 8; 11578c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (!isInc) 11588c11a65c18ae607b7073e1e451264492d2297726Chris Lattner size = -size; 11598c11a65c18ae607b7073e1e451264492d2297726Chris Lattner Inc = llvm::ConstantInt::get(Inc->getType(), size); 11608c11a65c18ae607b7073e1e451264492d2297726Chris Lattner const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 11618c11a65c18ae607b7073e1e451264492d2297726Chris Lattner InVal = Builder.CreateBitCast(InVal, i8Ty); 11628c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateGEP(InVal, Inc, "add.ptr"); 11638c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *lhs = LV.getAddress(); 11648c11a65c18ae607b7073e1e451264492d2297726Chris Lattner lhs = Builder.CreateBitCast(lhs, llvm::PointerType::getUnqual(i8Ty)); 11658c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LV = LValue::MakeAddr(lhs, CGF.MakeQualifiers(ValTy)); 11668c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else 11678c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateInBoundsGEP(InVal, Inc, "ptrincdec"); 11688c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 11698c11a65c18ae607b7073e1e451264492d2297726Chris Lattner const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 11708c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateBitCast(InVal, i8Ty, "tmp"); 11718c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateGEP(NextVal, Inc, "ptrincdec"); 11728c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateBitCast(NextVal, InVal->getType()); 11738c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 11748c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else if (InVal->getType()->isIntegerTy(1) && isInc) { 11758c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool++ is an interesting case, due to promotion rules, we get: 11768c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool++ -> Bool = Bool+1 -> Bool = (int)Bool+1 -> 11778c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool = ((int)Bool+1) != 0 11788c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // An interesting aspect of this is that increment is always true. 11798c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Decrement does not have this property. 11808c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantInt::getTrue(VMContext); 11818c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else if (isa<llvm::IntegerType>(InVal->getType())) { 11828c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal); 11838c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 1184640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner if (!ValTy->isSignedIntegerType()) 1185640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner // Unsigned integer inc is always two's complement. 11868c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1187640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner else { 1188640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1189640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Undefined: 1190640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner NextVal = Builder.CreateNSWAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1191640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner break; 1192640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Defined: 1193640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1194640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner break; 1195640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Trapping: 1196640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOpInfo BinOp; 1197640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.LHS = InVal; 1198640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.RHS = NextVal; 1199640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.Ty = E->getType(); 1200640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.Opcode = BinaryOperator::Add; 1201640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.E = E; 1202401be6bddcf05ac2828730e0bb4e8b81931f8296John McCall NextVal = EmitOverflowCheckedBinOp(BinOp); 1203401be6bddcf05ac2828730e0bb4e8b81931f8296John McCall break; 1204640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner } 1205640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner } 12068c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 12078c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Add the inc/dec to the real part. 12088c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (InVal->getType()->isFloatTy()) 12098c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = 12108c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::ConstantFP::get(VMContext, 12118c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat(static_cast<float>(AmountVal))); 12128c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else if (InVal->getType()->isDoubleTy()) 12138c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = 12148c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::ConstantFP::get(VMContext, 12158c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat(static_cast<double>(AmountVal))); 12168c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else { 12178c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat F(static_cast<float>(AmountVal)); 12188c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool ignored; 12198c11a65c18ae607b7073e1e451264492d2297726Chris Lattner F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 12208c11a65c18ae607b7073e1e451264492d2297726Chris Lattner &ignored); 12218c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantFP::get(VMContext, F); 12228c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 12238c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateFAdd(InVal, NextVal, isInc ? "inc" : "dec"); 12248c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 12258c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12268c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Store the updated result through the lvalue. 12278c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (LV.isBitField()) 12288c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.EmitStoreThroughBitfieldLValue(RValue::get(NextVal), LV, ValTy, &NextVal); 12298c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else 12308c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.EmitStoreThroughLValue(RValue::get(NextVal), LV, ValTy); 12318c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12328c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // If this is a postinc, return the value read from memory, otherwise use the 12338c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // updated value. 12348c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return isPre ? NextVal : InVal; 12358c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 12368c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12378c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12388c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 12407f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 12419a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Emit unary minus with EmitSub so we handle overflow cases etc. 12429a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOpInfo BinOp; 12434ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.RHS = Visit(E->getSubExpr()); 12444ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner 12454ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner if (BinOp.RHS->getType()->isFPOrFPVectorTy()) 12464ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType()); 12474ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner else 12484ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType()); 12499a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.Ty = E->getType(); 12509a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.Opcode = BinaryOperator::Sub; 12519a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.E = E; 12529a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner return EmitSub(BinOp); 12537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 12567f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 12577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 12587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNot(Op, "neg"); 12597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 12627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Compare operand to zero. 12637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 1264db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 12657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Invert value. 12667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // TODO: Could dynamically modify easy computations here. For example, if 12677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // the operand is an icmp ne, turn into icmp eq. 12687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BoolVal = Builder.CreateNot(BoolVal, "lnot"); 1269db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 12709f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson // ZExt result to the expr type. 12719f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext"); 12727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12740027d2bb24db629a33a71d04a5fb90a14c15a680Eli FriedmanValue *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) { 12750027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Try folding the offsetof to a constant. 12760027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr::EvalResult EvalResult; 12770027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (E->Evaluate(EvalResult, CGF.getContext())) 12780027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman return llvm::ConstantInt::get(VMContext, EvalResult.Val.getInt()); 12790027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 12800027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Loop over the components of the offsetof to compute the value. 12810027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned n = E->getNumComponents(); 12820027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const llvm::Type* ResultType = ConvertType(E->getType()); 12830027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Result = llvm::Constant::getNullValue(ResultType); 12840027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman QualType CurrentType = E->getTypeSourceInfo()->getType(); 12850027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (unsigned i = 0; i != n; ++i) { 12860027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman OffsetOfExpr::OffsetOfNode ON = E->getComponent(i); 128716fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman llvm::Value *Offset = 0; 12880027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman switch (ON.getKind()) { 12890027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Array: { 12900027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index 12910027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex()); 12920027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr); 12930027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman bool IdxSigned = IdxExpr->getType()->isSignedIntegerType(); 12940027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv"); 12950027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 12960027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type 12970027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = 12980027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getAsArrayType(CurrentType)->getElementType(); 12990027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13000027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the element size 13010027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType, 13020027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity()); 13030027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13040027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Multiply out to compute the result 13050027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = Builder.CreateMul(Idx, ElemSize); 13060027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 13070027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 13080027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13090027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Field: { 13100027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldDecl *MemberDecl = ON.getField(); 13110027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 13120027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 13130027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13140027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index of the field in its parent. 13150027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned i = 0; 13160027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // FIXME: It would be nice if we didn't have to loop here! 13170027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (RecordDecl::field_iterator Field = RD->field_begin(), 13180027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldEnd = RD->field_end(); 13190027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Field != FieldEnd; (void)++Field, ++i) { 13200027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (*Field == MemberDecl) 13210027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 13220027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 13230027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman assert(i < RL.getFieldCount() && "offsetof field in wrong type"); 13240027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13250027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the field 13260027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman int64_t OffsetInt = RL.getFieldOffset(i) / 13270027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 13280027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 13290027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13300027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 13310027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = MemberDecl->getType(); 13320027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 13330027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 133416fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 13350027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Identifier: 13366d4e44b462fe9e870a40358522379400ccc6e3c2Eli Friedman llvm_unreachable("dependent __builtin_offsetof"); 133716fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 13380027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Base: { 13390027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (ON.getBase()->isVirtual()) { 13400027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.ErrorUnsupported(E, "virtual base in offsetof"); 13410027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman continue; 13420027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 13430027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13440027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 13450027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 13460027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13470027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 13480027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = ON.getBase()->getType(); 13490027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13500027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the base. 13510027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const RecordType *BaseRT = CurrentType->getAs<RecordType>(); 13520027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl()); 13530027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman int64_t OffsetInt = RL.getBaseClassOffset(BaseRD) / 13540027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 13550027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 13560027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 13570027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 13580027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 13590027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Result = Builder.CreateAdd(Result, Offset); 13600027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 13610027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman return Result; 13628ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor} 13638ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 13640518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// VisitSizeOfAlignOfExpr - Return the size or alignment of the type of 13650518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// argument of the sizeof expression as an integer. 13660518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlValue * 13670518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) { 13680518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl QualType TypeToSize = E->getTypeOfArgument(); 1369f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isSizeOf()) { 1370db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (const VariableArrayType *VAT = 1371f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.getContext().getAsVariableArrayType(TypeToSize)) { 1372f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isArgumentType()) { 1373f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // sizeof(type) - make sure to emit the VLA size. 1374f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.EmitVLASize(TypeToSize); 13758f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman } else { 13768f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // C99 6.5.3.4p2: If the argument is an expression of type 13778f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // VLA, it is evaluated. 13788f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman CGF.EmitAnyExpr(E->getArgumentExpr()); 1379f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman } 1380db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 138196f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson return CGF.GetVLASize(VAT); 1382b50525ba0e996bc072cdb76152fcfe0bc64bb72aAnders Carlsson } 13835d46315ca3cbbfe0d0f5f65520b618fb05dd4446Anders Carlsson } 1384f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman 1385db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If this isn't sizeof(vla), the result must be constant; use the constant 1386db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // folding logic so we don't have to duplicate it here. 1387f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman Expr::EvalResult Result; 1388f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman E->Evaluate(Result, CGF.getContext()); 13894a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 13907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 139246f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 139346f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 13949b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (Op->getType()->isAnyComplexType()) 13957f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return CGF.EmitComplexExpr(Op, false, true, false, true).first; 139646f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return Visit(Op); 139746f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 139846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 139946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 14009b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (Op->getType()->isAnyComplexType()) 14017f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return CGF.EmitComplexExpr(Op, true, false, true, false).second; 1402db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 14037f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __imag on a scalar returns zero. Emit the subexpr to ensure side 14047f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // effects are evaluated, but not the actual value. 14057f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (E->isLvalue(CGF.getContext()) == Expr::LV_Valid) 14067f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitLValue(Op); 14077f79f9be5916c51c35da4f126b7c12596a101607Mike Stump else 14087f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitScalarExpr(Op, true); 1409c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson return llvm::Constant::getNullValue(ConvertType(E->getType())); 141046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 141146f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 14121eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpValue *ScalarExprEmitter::VisitUnaryOffsetOf(const UnaryOperator *E) { 141335183aca180a2b9b2c637cd625a40a7e147d6a32Eli Friedman Value* ResultAsPtr = EmitLValue(E->getSubExpr()).getAddress(); 1414769e411b72465a63454cdd416ff26ff313d43505Eli Friedman const llvm::Type* ResultType = ConvertType(E->getType()); 141535183aca180a2b9b2c637cd625a40a7e147d6a32Eli Friedman return Builder.CreatePtrToInt(ResultAsPtr, ResultType, "offsetof"); 14165a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 141746f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 14187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 14197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Binary Operators 14207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 14217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerBinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 14237f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 14247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BinOpInfo Result; 14257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.LHS = Visit(E->getLHS()); 14267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.RHS = Visit(E->getRHS()); 14271f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Result.Ty = E->getType(); 14289a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner Result.Opcode = E->getOpcode(); 14297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.E = E; 14307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Result; 14317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14336a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue ScalarExprEmitter::EmitCompoundAssignLValue( 14346a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E, 14356a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), 1436d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result) { 143754d76db0aa7107597cac0b80d8e138a37e6d1de9Benjamin Kramer QualType LHSTy = E->getLHS()->getType(); 14381f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo OpInfo; 14396a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1440ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman if (E->getComputationResultType()->isAnyComplexType()) { 1441db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // This needs to go through the complex expression emitter, but it's a tad 1442db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // complicated to do that... I'm leaving it out for now. (Note that we do 1443db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // actually need the imaginary part of the RHS for multiplication and 1444db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // division.) 1445ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman CGF.ErrorUnsupported(E, "complex compound assignment"); 1446d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = llvm::UndefValue::get(CGF.ConvertType(E->getType())); 14476a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LValue(); 14481f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 14496a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1450cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // Emit the RHS first. __block variables need to have the rhs evaluated 1451cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // first, plus this should improve codegen a little. 1452cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.RHS = Visit(E->getRHS()); 1453cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.Ty = E->getComputationResultType(); 14549a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OpInfo.Opcode = E->getOpcode(); 1455cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.E = E; 1456ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // Load/convert the LHS. 1457b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHSLV = EmitCheckedLValue(E->getLHS()); 1458ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy); 1459ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 1460ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman E->getComputationLHSType()); 14616a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 14621f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Expand the binary operator. 1463d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = (this->*Func)(OpInfo); 14646a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 14658c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Convert the result back to the LHS type. 1466ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 14676a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1468db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Store the result value into the LHS lvalue. Bit-fields are handled 1469db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // specially because the result is altered by the store, i.e., [C99 6.5.16p1] 1470db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // 'An assignment expression has the value of the left operand after the 1471db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // assignment...'. 1472d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHSLV.isBitField()) 1473d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy, 1474d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar &Result); 1475d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 1476ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy); 1477d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 14786a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LHSLV; 14796a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 14806a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 14816a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorValue *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 14826a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 14836a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor bool Ignore = TestAndClearIgnoreResultAssign(); 1484d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *RHS; 1485d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar LValue LHS = EmitCompoundAssignLValue(E, Func, RHS); 1486d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1487d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 14887f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 14897f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 1490d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1491d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 1492d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHS.isPropertyRef() || LHS.isKVCRef()) 1493d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1494d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1495d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 1496d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 1497d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1498d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1499d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 1500d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return EmitLoadOfLValue(LHS, E->getType()); 15011f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner} 15021f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 15031f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 15047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 1505f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 15067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 1507f60946222721d9ba3c059563935c17b84703187aDouglas Gregor else if (Ops.Ty->hasUnsignedIntegerRepresentation()) 15087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 15097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 15107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 15117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 15127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 15147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Rem in C can't be a floating point type: C99 6.5.5p2. 15151f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner if (Ops.Ty->isUnsignedIntegerType()) 15167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 15177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 15187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 15197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 15207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15212add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike StumpValue *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 15222add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned IID; 15232add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned OpID = 0; 15245d8b2cf9fd704f6ca5e33525803a65421c0b440eMike Stump 15259a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner switch (Ops.Opcode) { 1526035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Add: 1527035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::AddAssign: 1528035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 1; 1529035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::sadd_with_overflow; 1530035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1531035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Sub: 1532035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::SubAssign: 1533035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 2; 1534035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::ssub_with_overflow; 1535035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1536035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Mul: 1537035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::MulAssign: 1538035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 3; 1539035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::smul_with_overflow; 1540035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1541035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump default: 1542035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump assert(false && "Unsupported operation for overflow detection"); 1543ab4eff620a9ce0ea62cdf29529a66c2c98d116f5Daniel Dunbar IID = 0; 1544035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump } 1545035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID <<= 1; 1546035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID |= 1; 1547035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump 15482add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 15492add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 15502add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1); 15512add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 15522add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 15532add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 15542add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 15552add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 15562add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Branch in case of overflow. 155793a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 155893a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn); 15592add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 15602add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateCondBr(overflow, overflowBB, continueBB); 15612add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 156293a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner // Handle overflow with llvm.trap. 156393a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner // TODO: it would be better to generate one of these blocks per function. 15642add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(overflowBB); 156593a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::Function *Trap = CGF.CGM.getIntrinsic(llvm::Intrinsic::trap); 156693a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner Builder.CreateCall(Trap); 156793a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner Builder.CreateUnreachable(); 156893a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner 156993a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner // Continue on. 15702add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(continueBB); 157193a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner return result; 15722add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump} 15737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { 157558f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (!Ops.Ty->isAnyPointerType()) { 1576f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 1577a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1578a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1579a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "add"); 1580a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1581a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 1582a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1583a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1584a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1585a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1586a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1587f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 158887415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFAdd(Ops.LHS, Ops.RHS, "add"); 1589bf933a0cb628670490c15367b3f5ccb3193354a7Dan Gohman 15907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 15912add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 1592daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 15937f215c12af4c3e7f81b24102a676aabfdb4e1566Chris Lattner // Must have binary (not unary) expr here. Unary pointer decrement doesn't 15949a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 15959a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 15969a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 159714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (Ops.Ty->isPointerType() && 15986217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek Ops.Ty->getAs<PointerType>()->isVariableArrayType()) { 1599daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size 16009a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer addition"); 1601daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 16029a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 16038f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Value *Ptr, *Idx; 16048f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Expr *IdxExp; 16059a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const PointerType *PT = BinOp->getLHS()->getType()->getAs<PointerType>(); 1606db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump const ObjCObjectPointerType *OPT = 16079a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<ObjCObjectPointerType>(); 160814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (PT || OPT) { 16098f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.LHS; 16108f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.RHS; 16119a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getRHS(); 161214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } else { // int + pointer 16139a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner PT = BinOp->getRHS()->getType()->getAs<PointerType>(); 16149a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OPT = BinOp->getRHS()->getType()->getAs<ObjCObjectPointerType>(); 161514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff assert((PT || OPT) && "Invalid add expr"); 16168f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.RHS; 16178f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.LHS; 16189a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getLHS(); 16198f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 16208f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner 16218f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 16227cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 16238f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // Zero or sign extend the pointer value based on whether the index is 16248f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // signed or not. 162577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *IdxType = CGF.IntPtrTy; 16269619662a1d42e2008b865d3459c0677e149dad1bChris Lattner if (IdxExp->getType()->isSignedIntegerType()) 16278f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 16288f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner else 16298f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 16308f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 163114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType ElementType = PT ? PT->getPointeeType() : OPT->getPointeeType(); 1632db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1633c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = ElementType->getAs<ObjCObjectType>()) { 1634db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 16354a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1636199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext().getTypeSizeInChars(OIT).getQuantity()); 16372a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 16383c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 16392a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 16402a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 16412a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1642db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 16432a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1644db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Explicitly handle GNU void* and function pointer arithmetic extensions. The 1645db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // GNU void* casts amount to no-ops since our void* type is i8*, but this is 1646db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // future proof. 1647b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (ElementType->isVoidType() || ElementType->isFunctionType()) { 16483c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1649b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 16502a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 1651b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1652db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1653db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1654664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ptr, Idx, "add.ptr"); 16557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 16567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { 16582add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump if (!isa<llvm::PointerType>(Ops.LHS->getType())) { 1659f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 1660a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1661a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1662a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub"); 1663a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1664a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 1665a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1666a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1667a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1668a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1669a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1670f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 167187415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFSub(Ops.LHS, Ops.RHS, "sub"); 16722eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner 16737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 16742add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 16751f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 16769a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Must have binary (not unary) expr here. Unary pointer increment doesn't 16779a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 16789a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 16799a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 16809a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner if (BinOp->getLHS()->getType()->isPointerType() && 16819a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<PointerType>()->isVariableArrayType()) { 1682daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size for 1683daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-int 1684daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the division needs to account for the VLA size for 1685daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-ptr. 16869a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer subtraction"); 1687daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 1688daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 16899a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const QualType LHSType = BinOp->getLHS()->getType(); 169014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType LHSElementType = LHSType->getPointeeType(); 16918c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar if (!isa<llvm::PointerType>(Ops.RHS->getType())) { 16928c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - int 16938c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *Idx = Ops.RHS; 16948c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 16957cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 16968c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Zero or sign extend the pointer value based on whether the index is 16978c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // signed or not. 169877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *IdxType = CGF.IntPtrTy; 16999a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner if (BinOp->getRHS()->getType()->isSignedIntegerType()) 17008c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 17018c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar else 17028c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 17038c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 17048c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateNeg(Idx, "sub.ptr.neg"); 1705b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar 1706db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1707c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = LHSElementType->getAs<ObjCObjectType>()) { 1708db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 17094a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1710199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext(). 1711199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getTypeSizeInChars(OIT).getQuantity()); 17122a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 17133c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 17142a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 17152a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr"); 17162a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1717db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 17182a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1719b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // Explicitly handle GNU void* and function pointer arithmetic 1720db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // extensions. The GNU void* casts amount to no-ops since our void* type is 1721db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // i8*, but this is future proof. 1722b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 17233c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1724b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1725b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr"); 1726b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1727db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1728db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1729664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ops.LHS, Idx, "sub.ptr"); 1730820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar } else { 17318c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - pointer 17328c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *LHS = Ops.LHS; 17338c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *RHS = Ops.RHS; 1734db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1735199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ElementSize; 1736820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar 1737e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Handle GCC extension for pointer arithmetic on void* and function pointer 1738e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // types. 1739e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 1740199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CharUnits::One(); 17418c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } else { 1742199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CGF.getContext().getTypeSizeInChars(LHSElementType); 17438c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 1744db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 17458c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar const llvm::Type *ResultType = ConvertType(Ops.Ty); 17468c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); 17478c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 17488c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 1749db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1750e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Optimize out the shift for element size of 1. 1751199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck if (ElementSize.isOne()) 1752e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner return BytesBetween; 1753df1109434abd465a4db2e6f69ec2688866660367Dan Gohman 1754df1109434abd465a4db2e6f69ec2688866660367Dan Gohman // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 1755db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // pointer difference in C is only defined in the case where both operands 1756db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // are pointing to elements of an array. 1757199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck Value *BytesPerElt = 1758199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck llvm::ConstantInt::get(ResultType, ElementSize.getQuantity()); 1759df1109434abd465a4db2e6f69ec2688866660367Dan Gohman return Builder.CreateExactSDiv(BytesBetween, BytesPerElt, "sub.ptr.div"); 17607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 17617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 17647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 17657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 17667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 17677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 17687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1769db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1770be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 1771be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1772be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1773be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1774be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1775be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 177615037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 1777be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 1778be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 1779be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 17807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateShl(Ops.LHS, RHS, "shl"); 17817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 17847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 17857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 17867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 17877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 17887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1789db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1790be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 1791be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1792be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1793be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1794be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1795be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 179615037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 1797be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 1798be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 1799be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 1800f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasUnsignedIntegerRepresentation()) 18017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 18027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 18037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 18047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 18057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 18067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc) { 18077f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 18084f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *Result; 18097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner QualType LHSTy = E->getLHS()->getType(); 1810b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman if (LHSTy->isMemberFunctionPointerType()) { 1811b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *LHSPtr = CGF.EmitAnyExprToTemp(E->getLHS()).getAggregateAddr(); 1812b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *RHSPtr = CGF.EmitAnyExprToTemp(E->getRHS()).getAggregateAddr(); 1813b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *LHSFunc = Builder.CreateStructGEP(LHSPtr, 0); 1814b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSFunc = Builder.CreateLoad(LHSFunc); 1815b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *RHSFunc = Builder.CreateStructGEP(RHSPtr, 0); 1816b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman RHSFunc = Builder.CreateLoad(RHSFunc); 1817b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *ResultF = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1818b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSFunc, RHSFunc, "cmp.func"); 1819b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *NullPtr = llvm::Constant::getNullValue(LHSFunc->getType()); 1820b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *ResultNull = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1821b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSFunc, NullPtr, "cmp.null"); 1822b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *LHSAdj = Builder.CreateStructGEP(LHSPtr, 1); 1823b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSAdj = Builder.CreateLoad(LHSAdj); 1824b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *RHSAdj = Builder.CreateStructGEP(RHSPtr, 1); 1825b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman RHSAdj = Builder.CreateLoad(RHSAdj); 1826b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *ResultA = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1827b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSAdj, RHSAdj, "cmp.adj"); 1828b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman if (E->getOpcode() == BinaryOperator::EQ) { 1829b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateOr(ResultNull, ResultA, "or.na"); 1830b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateAnd(Result, ResultF, "and.f"); 1831b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else { 1832b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman assert(E->getOpcode() == BinaryOperator::NE && 1833b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman "Member pointer comparison other than == or != ?"); 1834b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateAnd(ResultNull, ResultA, "and.na"); 1835b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateOr(Result, ResultF, "or.f"); 1836b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } 1837b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else if (!LHSTy->isAnyComplexType()) { 18387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS = Visit(E->getLHS()); 18397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 1840db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1841f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (LHS->getType()->isFPOrFPVectorTy()) { 18427a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 18437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 1844f60946222721d9ba3c059563935c17b84703187aDouglas Gregor } else if (LHSTy->hasSignedIntegerRepresentation()) { 1845ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 18467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 18477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 1848ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman // Unsigned integers and pointers. 1849ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 18507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 18517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 18529c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner 18539c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // If this is a vector comparison, sign extend the result to the appropriate 18549c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // vector integer type and return it (don't convert to bool). 18559c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner if (LHSTy->isVectorType()) 18569c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 1857db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 18597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex Comparison: can only be an equality comparison. 18607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 18617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 1862db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1863183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType CETy = LHSTy->getAs<ComplexType>()->getElementType(); 1864db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18654f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *ResultR, *ResultI; 18667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (CETy->isRealFloatingType()) { 18677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 18687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 18697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 18707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 18717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 18727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex comparisons can only be equality comparisons. As such, signed 18737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // and unsigned opcodes are the same. 18747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 18757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 18767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 18777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 18787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1879db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getOpcode() == BinaryOperator::EQ) { 18817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 18827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 18837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E->getOpcode() == BinaryOperator::NE && 18847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Complex comparison other than == or != ?"); 18857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 18867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 18877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 188832f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes 188932f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 18907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 18917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 18927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 18937f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool Ignore = TestAndClearIgnoreResultAssign(); 18947f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 18957f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __block variables need to have the rhs evaluated first, plus this should 18967f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // improve codegen just a little. 18977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 1898b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHS = EmitCheckedLValue(E->getLHS()); 1899db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1900ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar // Store the value into the LHS. Bit-fields are handled specially 1901371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // because the result is altered by the store, i.e., [C99 6.5.16p1] 1902371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // 'An assignment expression has the value of the left operand after 1903daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // the assignment...'. 1904d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHS.isBitField()) 1905d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType(), 1906d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar &RHS); 1907d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 1908ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType()); 1909d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1910d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 19117f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 19127f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 1913d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1914d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 1915d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHS.isPropertyRef() || LHS.isKVCRef()) 1916d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1917d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1918d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 1919d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 1920d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1921d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1922d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 19237f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitLoadOfLValue(LHS, E->getType()); 19247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 19277804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 19287804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 192920eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 193020eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 && X, just emit X without inserting the control flow. 193120eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 193220eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == 1) { // If we have 1 && X, just emit X. 19330946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 19347804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 19357804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 19360946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1937db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19387804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 193920eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 19407804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::Constant::getNullValue(ResTy); 19410946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1942db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19439615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 19449615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 194520eb09d562b80420a3328be789547af354bf3e36Chris Lattner 1946f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is false, go to the failure (cont) block. 1947f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 1948f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1949f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 1950f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be false. Start 1951f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 19520032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 19530032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 1954f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 1955f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 1956f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 19573b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 1958db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 195972119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 19607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 19617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 196272119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 1963db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 19657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 1966f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1967f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 1968f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 19697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 19707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 1971db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 19737804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 19747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 19777804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 19787804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 197920eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 198020eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 || X, just emit X without inserting the control flow. 198120eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 198220eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == -1) { // If we have 0 || X, just emit X. 19830946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 19847804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 19857804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 19860946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1987db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19887804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 198920eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 19907804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::ConstantInt::get(ResTy, 1); 19910946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1992db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19939615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 19949615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 1995db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1996f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is true, go to the success (cont) block. 1997f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 1998f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1999f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2000f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be true. Start 2001f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 20020032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 20030032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2004f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 2005f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2006f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 20073b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 2008f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 200972119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 201033da07db112f4877f6ab13e20db08b9bb86a0c2eAnders Carlsson 2011f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit the RHS condition as a bool value. 20127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 20137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2014db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 201572119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 2016db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 20187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2019db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2020f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2021f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 2022f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBlock(ContBlock); 20237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2024db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 20267804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 20277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 20297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 20307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitStmt(E->getLHS()); 2031a448fb2da03ece39978784793eea68760e8205a1Daniel Dunbar CGF.EnsureInsertPoint(); 20327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getRHS()); 20337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 20357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 20367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Other Operators 20377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 20387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 20399802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 20409802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// expression is cheap enough and side-effect-free enough to evaluate 20419802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// unconditionally instead of conditionally. This is used to convert control 20429802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// flow into selects in some cases. 2043df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stumpstatic bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 2044df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CodeGenFunction &CGF) { 20459802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) 2046df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr(), CGF); 2047db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20489802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // TODO: Allow anything we can constant fold to an integer or fp constant. 20499802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) || 20509802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner isa<FloatingLiteral>(E)) 20519802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2052db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20539802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // Non-volatile automatic variables too, to get "cond ? X : Y" where 20549802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // X and Y are local variables. 20559802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 20569802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 2057df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (VD->hasLocalStorage() && !(CGF.getContext() 2058df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .getCanonicalType(VD->getType()) 2059df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .isVolatileQualified())) 20609802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2061db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20629802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return false; 20639802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner} 20649802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 20659802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 20667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter:: 20677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerVisitConditionalOperator(const ConditionalOperator *E) { 20687f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 206931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the condition constant folds and can be elided, try to avoid emitting 207031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the condition and the dead arm. 207131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getCond())){ 2072c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner Expr *Live = E->getLHS(), *Dead = E->getRHS(); 207331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (Cond == -1) 2074c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner std::swap(Live, Dead); 2075db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 207631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the dead side doesn't have labels we need, and if the Live side isn't 207731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the gnu missing ?: extension (which we could handle, but don't bother 207831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // to), just emit the Live part. 207931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if ((!Dead || !CGF.ContainsLabel(Dead)) && // No labels in dead part 208031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Live) // Live part isn't missing. 208131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return Visit(Live); 2082c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner } 2083db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2084db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20859802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // If this is a really simple expression (like x ? 4 : 5), emit this as a 20869802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // select instead of as control flow. We can only do this if it is cheap and 2087531a550531c144a58438f187816abbf1879e1c4eChris Lattner // safe to evaluate the LHS and RHS unconditionally. 2088df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (E->getLHS() && isCheapEnoughToEvaluateUnconditionally(E->getLHS(), 2089df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CGF) && 2090df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump isCheapEnoughToEvaluateUnconditionally(E->getRHS(), CGF)) { 20919802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *CondV = CGF.EvaluateExprAsBool(E->getCond()); 20929802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *LHS = Visit(E->getLHS()); 20939802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *RHS = Visit(E->getRHS()); 20949802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 20959802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner } 2096db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2097db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2098be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 2099be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 21009615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 2101035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Value *CondVal = 0; 2102035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner 2103db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If we don't have the GNU missing condition extension, emit a branch on bool 2104db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // the normal way. 210512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner if (E->getLHS()) { 210612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for 210712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the branch on bool. 210812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 210912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner } else { 211012d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, for the ?: extension, evaluate the conditional and then 211112d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // convert it to bool the hard way. We do this explicitly because we need 211212d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the unconverted value for the missing middle value of the ?:. 2113035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CondVal = CGF.EmitScalarExpr(E->getCond()); 2114db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 211512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // In some cases, EmitScalarConversion will delete the "CondVal" expression 211612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // if there are no extra uses (an optimization). Inhibit this by making an 211712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // extra dead use, because we're going to add a use of CondVal later. We 211812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // don't use the builder for this, because we don't want it to get optimized 211912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // away. This leaves dead code, but the ?: extension isn't common. 212012d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner new llvm::BitCastInst(CondVal, CondVal->getType(), "dummy?:holder", 212112d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner Builder.GetInsertBlock()); 2122db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2123035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Value *CondBoolVal = 2124035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.EmitScalarConversion(CondVal, E->getCond()->getType(), 2125035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.getContext().BoolTy); 2126035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock); 2127035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner } 2128fb6fa30a9b06670deb14f862dddbc49a12552939Anders Carlsson 212972119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 21307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(LHSBlock); 2131db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the GNU extension for missing LHS. 2133a21ddb30e56026967d58e26c5212744e1831305bChris Lattner Value *LHS; 2134a21ddb30e56026967d58e26c5212744e1831305bChris Lattner if (E->getLHS()) 2135856226c37ff10955c7f3f07ce6fa9522da23a3a5Eli Friedman LHS = Visit(E->getLHS()); 2136a21ddb30e56026967d58e26c5212744e1831305bChris Lattner else // Perform promotions, to handle cases like "short ?: int" 2137a21ddb30e56026967d58e26c5212744e1831305bChris Lattner LHS = EmitScalarConversion(CondVal, E->getCond()->getType(), E->getType()); 2138db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 213972119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 21407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHSBlock = Builder.GetInsertBlock(); 2141d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 2142db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 214372119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 21447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 2145db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2146856226c37ff10955c7f3f07ce6fa9522da23a3a5Eli Friedman Value *RHS = Visit(E->getRHS()); 214772119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 21487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2149d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 2150db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 2152db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 215348daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman // If the LHS or RHS is a throw expression, it will be legitimately null. 215448daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!LHS) 215548daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return RHS; 215648daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!RHS) 215748daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return LHS; 2158db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Create a PHI node for the real part. 21607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond"); 21617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->reserveOperandSpace(2); 21627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(LHS, LHSBlock); 21637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHS, RHSBlock); 21647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return PN; 21657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 21667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 21677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 21687976932a1c256d447316ffac58e9821417725e34Eli Friedman return Visit(E->getChosenSubExpr(CGF.getContext())); 21697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 21707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 21712202bce80fc72d067cbe67dc1512f7b45351fd31Chris LattnerValue *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 21724fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 2173ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 2174ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 2175ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson // If EmitVAArg fails, we fall back to the LLVM instruction. 2176db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (!ArgPtr) 2177ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 2178ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 21797f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // FIXME Volatility. 2180ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateLoad(ArgPtr); 21817c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson} 21827c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 2183df6b68c9487aed2042c7fc23db10a79f89083a11Mike StumpValue *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *BE) { 21840892099dbc640720400a1d9decd2733a09d733e5Mike Stump return CGF.BuildBlockLiteralTmp(BE); 2185df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump} 2186df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 21877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 21887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Entry Point into this File 21897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 21907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2191db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitScalarExpr - Emit the computation of the specified expression of scalar 2192db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type, ignoring the result. 21937f79f9be5916c51c35da4f126b7c12596a101607Mike StumpValue *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 21947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E && !hasAggregateLLVMType(E->getType()) && 21957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Invalid scalar expression to emit"); 2196db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21977f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return ScalarExprEmitter(*this, IgnoreResultAssign) 21987f79f9be5916c51c35da4f126b7c12596a101607Mike Stump .Visit(const_cast<Expr*>(E)); 21997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 22003707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 22013707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 22023707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 22034f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 22044f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 22053707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 22063707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner "Invalid scalar expression to emit"); 22073707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 22083707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 22094f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 2210db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 2211db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 2212db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 22134f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 22144f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, 22154f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 22169b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 22174f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner "Invalid complex -> scalar conversion"); 22184f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 22194f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner DstTy); 22204f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 2221cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 22228c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 22238c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *CodeGenFunction:: 22248c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 22258c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 22268c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre); 22278c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 22288c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2229820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz JahanianLValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 2230820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian llvm::Value *V; 2231820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // object->isa or (*object).isa 2232820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // Generate code as for: *(Class*)object 22335ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian // build Class* type 22345ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian const llvm::Type *ClassPtrTy = ConvertType(E->getType()); 22355ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian 2236820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Expr *BaseExpr = E->getBase(); 22375ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian if (BaseExpr->isLvalue(getContext()) != Expr::LV_Valid) { 22385ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = CreateTempAlloca(ClassPtrTy, "resval"); 22395ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian llvm::Value *Src = EmitScalarExpr(BaseExpr); 22405ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian Builder.CreateStore(Src, V); 22419f9efe6d58f49bce01b548bf81245f053b632a02Fariborz Jahanian LValue LV = LValue::MakeAddr(V, MakeQualifiers(E->getType())); 22429f9efe6d58f49bce01b548bf81245f053b632a02Fariborz Jahanian V = ScalarExprEmitter(*this).EmitLoadOfLValue(LV, E->getType()); 22435ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 22445ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian else { 22455ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian if (E->isArrow()) 22465ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr); 22475ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian else 22485ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = EmitLValue(BaseExpr).getAddress(); 22495ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 2250820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 2251820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // build Class* type 2252820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian ClassPtrTy = ClassPtrTy->getPointerTo(); 2253820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian V = Builder.CreateBitCast(V, ClassPtrTy); 2254820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian LValue LV = LValue::MakeAddr(V, MakeQualifiers(E->getType())); 2255820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian return LV; 2256820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian} 2257820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 22586a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 22596a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue CodeGenFunction::EmitCompoundAssignOperatorLValue( 22606a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E) { 22616a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor ScalarExprEmitter Scalar(*this); 2262d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *Result = 0; 22636a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor switch (E->getOpcode()) { 22646a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#define COMPOUND_OP(Op) \ 22656a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Op##Assign: \ 22666a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 2267d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result) 22686a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Mul); 22696a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Div); 22706a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Rem); 22716a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Add); 22726a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Sub); 22736a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shl); 22746a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shr); 22756a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(And); 22766a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Xor); 22776a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Or); 22786a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#undef COMPOUND_OP 22796a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 22806a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::PtrMemD: 22816a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::PtrMemI: 22826a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Mul: 22836a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Div: 22846a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Rem: 22856a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Add: 22866a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Sub: 22876a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Shl: 22886a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Shr: 22896a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LT: 22906a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::GT: 22916a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LE: 22926a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::GE: 22936a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::EQ: 22946a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::NE: 22956a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::And: 22966a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Xor: 22976a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Or: 22986a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LAnd: 22996a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LOr: 23006a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Assign: 23016a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Comma: 23026a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor assert(false && "Not valid compound assignment operators"); 23036a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor break; 23046a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor } 23056a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 23066a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor llvm_unreachable("Unhandled compound assignment operator"); 23076a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 2308