CGExprScalar.cpp revision 640d3267228415328c0feb2bcc35757230ab4db7
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 } 1297267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis Value *VisitCXXZeroInitValueExpr(const CXXZeroInitValueExpr *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 } 1408ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor Value *VisitOffsetOfExpr(const 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) { 300a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner if (Ops.Ty->isSignedIntegerType()) { 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 &), 3376a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *&BitFieldResult); 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 4520032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::LLVMContext &VMContext = CGF.getLLVMContext(); 4533707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4543707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 455ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstType->isBooleanType()) 456ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return EmitConversionToBool(Src, SrcType); 457db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4583707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner const llvm::Type *DstTy = ConvertType(DstType); 4593707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4603707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Ignore conversions like int -> uint. 4613707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (Src->getType() == DstTy) 4623707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Src; 4633707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 464db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle pointer conversions next: pointers can only be converted to/from 465db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // other pointers and integers. Check for pointer types in terms of LLVM, as 466db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // some native types (like Obj-C id) may map to a pointer type. 467270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(DstTy)) { 4683707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // The source value may be an integer, or a pointer. 469191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson if (isa<llvm::PointerType>(Src->getType())) 4703707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Builder.CreateBitCast(Src, DstTy, "conv"); 471191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 4723707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 47325615424741bcce31fe52c896f76268f0307f00dEli Friedman // First, convert to the correct width so that we control the kind of 47425615424741bcce31fe52c896f76268f0307f00dEli Friedman // extension. 475db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump const llvm::Type *MiddleTy = 4760032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::IntegerType::get(VMContext, CGF.LLVMPointerWidth); 47725615424741bcce31fe52c896f76268f0307f00dEli Friedman bool InputSigned = SrcType->isSignedIntegerType(); 47825615424741bcce31fe52c896f76268f0307f00dEli Friedman llvm::Value* IntResult = 47925615424741bcce31fe52c896f76268f0307f00dEli Friedman Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 48025615424741bcce31fe52c896f76268f0307f00dEli Friedman // Then, cast to pointer. 48125615424741bcce31fe52c896f76268f0307f00dEli Friedman return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 4823707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 483db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 484270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(Src->getType())) { 4853707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Must be an ptr to int cast. 4863707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 48750b5a30db40322880340e957ad7d6d8d60bb4c5bAnders Carlsson return Builder.CreatePtrToInt(Src, DstTy, "conv"); 4883707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 489db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 490213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // A scalar can be splatted to an extended vector of the same element type 4912ef13e5abef0570a9f567b4671367275c05d4d34Nate Begeman if (DstType->isExtVectorType() && !SrcType->isVectorType()) { 4926fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Cast the scalar to element type 493183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType EltTy = DstType->getAs<ExtVectorType>()->getElementType(); 4946fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 4956fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 4966fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Insert the element in element zero of an undef vector 49703e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::Value *UnV = llvm::UndefValue::get(DstTy); 4980032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::Value *Idx = 4990032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 0); 5006fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 5016fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 5026fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Splat the element across to all elements 5036fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 5046fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 5056fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman for (unsigned i = 0; i < NumElements; i++) 5060032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson Args.push_back(llvm::ConstantInt::get( 5070032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::Type::getInt32Ty(VMContext), 0)); 508db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5094a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 5106fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 5116fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman return Yay; 5126fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman } 5134119d1aeca8016654d381ce079864058d1709571Nate Begeman 5143b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner // Allow bitcast from vector to integer/fp of the same size. 5157019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson if (isa<llvm::VectorType>(Src->getType()) || 5163b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner isa<llvm::VectorType>(DstTy)) 5177019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson return Builder.CreateBitCast(Src, DstTy, "conv"); 518db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5193707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Finally, we have the arithmetic types: real int/float. 5203707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(Src->getType())) { 5213707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner bool InputSigned = SrcType->isSignedIntegerType(); 522b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (isa<llvm::IntegerType>(DstTy)) 523b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 524b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else if (InputSigned) 525b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateSIToFP(Src, DstTy, "conv"); 526b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 527b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateUIToFP(Src, DstTy, "conv"); 5283707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 529db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 530f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(Src->getType()->isFloatingPointTy() && "Unknown real conversion"); 5313707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(DstTy)) { 532b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstType->isSignedIntegerType()) 533b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToSI(Src, DstTy, "conv"); 534b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 535b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToUI(Src, DstTy, "conv"); 5363707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 5373707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 538f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(DstTy->isFloatingPointTy() && "Unknown real conversion"); 539b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstTy->getTypeID() < Src->getType()->getTypeID()) 540b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPTrunc(Src, DstTy, "conv"); 541b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 542b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPExt(Src, DstTy, "conv"); 5433707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 5443707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 545db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 546db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 547db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 5484f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter:: 5494f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerEmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 5504f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy) { 551ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Get the source element type. 552183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall SrcTy = SrcTy->getAs<ComplexType>()->getElementType(); 553db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 554ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 555ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstTy->isBooleanType()) { 556ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Complex != 0 -> (Real != 0) | (Imag != 0) 557ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 558ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 559ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return Builder.CreateOr(Src.first, Src.second, "tobool"); 560ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner } 561db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5624f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 5634f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // the imaginary part of the complex value is discarded and the value of the 5644f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // real part is converted according to the conversion rules for the 565db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // corresponding real type. 5664f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return EmitScalarConversion(Src.first, SrcTy, DstTy); 5674f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 5684f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 569a40a9f31218c743e366322e34b59f0d4d4414198Anders CarlssonValue *ScalarExprEmitter::EmitNullValue(QualType Ty) { 570a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson const llvm::Type *LTy = ConvertType(Ty); 571a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 572a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson if (!Ty->isMemberPointerType()) 573a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return llvm::Constant::getNullValue(LTy); 574a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 575a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson assert(!Ty->isMemberFunctionPointerType() && 576a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson "member function pointers are not scalar!"); 577a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 578a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson // Itanium C++ ABI 2.3: 579a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson // A NULL pointer is represented as -1. 580a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return llvm::ConstantInt::get(LTy, -1ULL, /*isSigned=*/true); 581a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson} 5824f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 5837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Visitor Methods 5857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitExpr(Expr *E) { 588488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGF.ErrorUnsupported(E, "scalar expression"); 5897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getType()->isVoidType()) 5907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 59103e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 5927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 5937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 594d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanValue *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 59537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Vector Mask Case 59637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 2 || 5973f4cb120fe574f7b80864f52a1999502a4f3a83dRafael Espindola (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { 59837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* LHS = CGF.EmitScalarExpr(E->getExpr(0)); 59937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* RHS = CGF.EmitScalarExpr(E->getExpr(1)); 60037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* Mask; 60137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 60237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::Type *I32Ty = llvm::Type::getInt32Ty(CGF.getLLVMContext()); 60337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType()); 60437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman unsigned LHSElts = LTy->getNumElements(); 60537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 60637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 3) { 60737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = CGF.EmitScalarExpr(E->getExpr(2)); 60837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 60937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Shuffle LHS & RHS into one input vector. 61037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> concat; 61137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0; i != LHSElts; ++i) { 61237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman concat.push_back(llvm::ConstantInt::get(I32Ty, 2*i)); 61337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman concat.push_back(llvm::ConstantInt::get(I32Ty, 2*i+1)); 61437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 61537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 61637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* CV = llvm::ConstantVector::get(concat.begin(), concat.size()); 61737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); 61837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHSElts *= 2; 61937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } else { 62037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = RHS; 62137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 62237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 62337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType()); 62437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant* EltMask; 62537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 62637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Treat vec3 like vec4. 62737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) 62837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 62937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+2))-1); 63037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else if ((LHSElts == 3) && (E->getNumSubExprs() == 2)) 63137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 63237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+1))-1); 63337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else 63437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 63537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts))-1); 63637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 63737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Mask off the high bits of each shuffle index. 63837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant *, 32> MaskV; 63937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) 64037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MaskV.push_back(EltMask); 64137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 64237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* MaskBits = llvm::ConstantVector::get(MaskV.begin(), MaskV.size()); 64337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); 64437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 64537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = undef 64637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // mask = mask & maskbits 64737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // for each elt 64837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // n = extract mask i 64937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // x = extract val n 65037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = insert newv, x, i 65137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(), 65237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MTy->getNumElements()); 65337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* NewV = llvm::UndefValue::get(RTy); 65437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) { 65537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *Indx = llvm::ConstantInt::get(I32Ty, i); 65637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateExtractElement(Mask, Indx, "shuf_idx"); 65737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateZExt(Indx, I32Ty, "idx_zext"); 65837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 65937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 66037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { 66137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *cmpIndx, *newIndx; 66237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman cmpIndx = Builder.CreateICmpUGT(Indx, llvm::ConstantInt::get(I32Ty, 3), 66337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "cmp_shuf_idx"); 66437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman newIndx = Builder.CreateSub(Indx, llvm::ConstantInt::get(I32Ty, 1), 66537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "shuf_idx_adj"); 66637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx"); 66737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 66837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt"); 66937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman NewV = Builder.CreateInsertElement(NewV, VExt, Indx, "shuf_ins"); 67037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 67137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman return NewV; 672d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 67337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 674d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 675d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 67637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 67737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 67837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> indices; 67937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 68037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant *C = cast<llvm::Constant>(CGF.EmitScalarExpr(E->getExpr(i))); 68137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *VTy = cast<llvm::VectorType>(V1->getType()); 68237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (VTy->getNumElements() == 3) { 68337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C)) { 68437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman uint64_t cVal = CI->getZExtValue(); 68537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (cVal > 3) { 68637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman C = llvm::ConstantInt::get(C->getType(), cVal-1); 68737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 68837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 68937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 69037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman indices.push_back(C); 69137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 69237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 6934a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson Value* SV = llvm::ConstantVector::get(indices.begin(), indices.size()); 694d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 695d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 69628665272c36cccb1014a6ea1217354b0519e2b59Eli FriedmanValue *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) { 69728665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 69828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 69928665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->isArrow()) 70028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman CGF.EmitScalarExpr(E->getBase()); 70128665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman else 70228665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman EmitLValue(E->getBase()); 70328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 70428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 70528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return EmitLoadOfLValue(E); 70628665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman} 707d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 7087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 7097f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 7107f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 7117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Emit subscript expressions in rvalue context's. For most cases, this just 7127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // loads the lvalue formed by the subscript expr. However, we have to be 7137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // careful, because the base of a vector subscript is occasionally an rvalue, 7147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // so we can't get it as an lvalue. 7157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (!E->getBase()->getType()->isVectorType()) 7167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 717db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 7187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the vector case. The base must be a vector, the index must be an 7197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // integer value. 7207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Base = Visit(E->getBase()); 7217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Idx = Visit(E->getIdx()); 722daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman bool IdxSigned = E->getIdx()->getType()->isSignedIntegerType(); 7230032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson Idx = Builder.CreateIntCast(Idx, 724db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Type::getInt32Ty(CGF.getLLVMContext()), 7250032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson IdxSigned, 726515ff5a31d75df9f4f099458a31cd7a405cf513dEli Friedman "vecidxcast"); 7277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateExtractElement(Base, Idx, "vecext"); 7287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 7297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7300533b3020ca39898751d4200feed776861dcd1ceNate Begemanstatic llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, 7310533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned Off, const llvm::Type *I32Ty) { 7320533b3020ca39898751d4200feed776861dcd1ceNate Begeman int MV = SVI->getMaskValue(Idx); 7330533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (MV == -1) 7340533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::UndefValue::get(I32Ty); 7350533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::ConstantInt::get(I32Ty, Off+MV); 7360533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 7370533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7380533b3020ca39898751d4200feed776861dcd1ceNate BegemanValue *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { 7390533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool Ignore = TestAndClearIgnoreResultAssign(); 7400533b3020ca39898751d4200feed776861dcd1ceNate Begeman (void)Ignore; 7410533b3020ca39898751d4200feed776861dcd1ceNate Begeman assert (Ignore == false && "init list ignored"); 7420533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned NumInitElements = E->getNumInits(); 7430533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7440533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (E->hadArrayRangeDesignator()) 7450533b3020ca39898751d4200feed776861dcd1ceNate Begeman CGF.ErrorUnsupported(E, "GNU array range designator extension"); 7460533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7470533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VType = 7480533b3020ca39898751d4200feed776861dcd1ceNate Begeman dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 7490533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7500533b3020ca39898751d4200feed776861dcd1ceNate Begeman // We have a scalar in braces. Just use the first element. 7510533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VType) 7520533b3020ca39898751d4200feed776861dcd1ceNate Begeman return Visit(E->getInit(0)); 7530533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7540533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned ResElts = VType->getNumElements(); 7550533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::Type *I32Ty = llvm::Type::getInt32Ty(CGF.getLLVMContext()); 7560533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7570533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Loop over initializers collecting the Value for each, and remembering 7580533b3020ca39898751d4200feed776861dcd1ceNate Begeman // whether the source was swizzle (ExtVectorElementExpr). This will allow 7590533b3020ca39898751d4200feed776861dcd1ceNate Begeman // us to fold the shuffle for the swizzle into the shuffle for the vector 7600533b3020ca39898751d4200feed776861dcd1ceNate Begeman // initializer, since LLVM optimizers generally do not want to touch 7610533b3020ca39898751d4200feed776861dcd1ceNate Begeman // shuffles. 7620533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned CurIdx = 0; 7630533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool VIsUndefShuffle = false; 7640533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *V = llvm::UndefValue::get(VType); 7650533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned i = 0; i != NumInitElements; ++i) { 7660533b3020ca39898751d4200feed776861dcd1ceNate Begeman Expr *IE = E->getInit(i); 7670533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Init = Visit(IE); 7680533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 7690533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7700533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType()); 7710533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7720533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Handle scalar elements. If the scalar initializer is actually one 7730533b3020ca39898751d4200feed776861dcd1ceNate Begeman // element of a different vector of the same width, use shuffle instead of 7740533b3020ca39898751d4200feed776861dcd1ceNate Begeman // extract+insert. 7750533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VVT) { 7760533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 7770533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init); 7780533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7790533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (EI->getVectorOperandType()->getNumElements() == ResElts) { 7800533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand()); 7810533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *LHS = 0, *RHS = 0; 7820533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) { 7830533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undef -> shuffle (src, undef) 7840533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(C); 7850533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 1; j != ResElts; ++j) 7860533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::UndefValue::get(I32Ty)); 7870533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7880533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = EI->getVectorOperand(); 7890533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = V; 7900533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = true; 7910533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else if (VIsUndefShuffle) { 7920533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undefshuffle && size match -> shuffle (v, src) 7930533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V); 7940533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 7950533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(SVV, j, 0, I32Ty)); 7960533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::ConstantInt::get(I32Ty, 7970533b3020ca39898751d4200feed776861dcd1ceNate Begeman ResElts + C->getZExtValue())); 7980533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + 1; j != ResElts; ++j) 7990533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::UndefValue::get(I32Ty)); 8000533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8010533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 8020533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = EI->getVectorOperand(); 8030533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8040533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8050533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!Args.empty()) { 8060533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 8070533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(LHS, RHS, Mask); 8080533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8090533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8100533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8110533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8120533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8130533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Idx = llvm::ConstantInt::get(I32Ty, CurIdx); 8140533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 8150533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8160533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8170533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8180533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8190533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8200533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned InitElts = VVT->getNumElements(); 8210533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8220533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's 8230533b3020ca39898751d4200feed776861dcd1ceNate Begeman // input is the same width as the vector being constructed, generate an 8240533b3020ca39898751d4200feed776861dcd1ceNate Begeman // optimized shuffle of the swizzle input into the result. 825a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman unsigned Offset = (CurIdx == 0) ? 0 : ResElts; 8260533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 8270533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init); 8280533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *SVOp = SVI->getOperand(0); 8290533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType()); 8300533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8310533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (OpTy->getNumElements() == ResElts) { 8320533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) { 8330533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the current vector initializer is a shuffle with undef, merge 8340533b3020ca39898751d4200feed776861dcd1ceNate Begeman // this shuffle directly into it. 8350533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) { 8360533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0, 8370533b3020ca39898751d4200feed776861dcd1ceNate Begeman I32Ty)); 8380533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else { 8390533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::ConstantInt::get(I32Ty, j)); 8400533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8410533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8420533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0, je = InitElts; j != je; ++j) 8430533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(SVI, j, Offset, I32Ty)); 8440533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 8450533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::UndefValue::get(I32Ty)); 8460533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8470533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) 8480533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 8490533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8500533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = SVOp; 8510533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8520533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8530533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8540533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Extend init to result vector length, and then shuffle its contribution 8550533b3020ca39898751d4200feed776861dcd1ceNate Begeman // to the vector initializer into V. 8560533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (Args.empty()) { 8570533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 8580533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::ConstantInt::get(I32Ty, j)); 8590533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = InitElts; j != ResElts; ++j) 8600533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::UndefValue::get(I32Ty)); 8610533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 8620533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), 863a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman Mask, "vext"); 8640533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8650533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.clear(); 8660533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 8670533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::ConstantInt::get(I32Ty, j)); 8680533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 869a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman Args.push_back(llvm::ConstantInt::get(I32Ty, j+Offset)); 8700533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 8710533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::UndefValue::get(I32Ty)); 8720533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8730533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8740533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If V is undef, make sure it ends up on the RHS of the shuffle to aid 8750533b3020ca39898751d4200feed776861dcd1ceNate Begeman // merging subsequent shuffles into this one. 8760533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) 8770533b3020ca39898751d4200feed776861dcd1ceNate Begeman std::swap(V, Init); 8780533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 8790533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit"); 8800533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = isa<llvm::UndefValue>(Init); 8810533b3020ca39898751d4200feed776861dcd1ceNate Begeman CurIdx += InitElts; 8820533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8830533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8840533b3020ca39898751d4200feed776861dcd1ceNate Begeman // FIXME: evaluate codegen vs. shuffling against constant null vector. 8850533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers. 8860533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::Type *EltTy = VType->getElementType(); 8870533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8880533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers 8890533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { 8900533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Idx = llvm::ConstantInt::get(I32Ty, CurIdx); 8910533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *Init = llvm::Constant::getNullValue(EltTy); 8920533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 8930533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8940533b3020ca39898751d4200feed776861dcd1ceNate Begeman return V; 8950533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 8960533b3020ca39898751d4200feed776861dcd1ceNate Begeman 897a3697c9c155bda93fd2802f37084b620f4738822Anders Carlssonstatic bool ShouldNullCheckClassCastValue(const CastExpr *CE) { 898a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const Expr *E = CE->getSubExpr(); 89923cba801e11b03929c44f8cf54578305963a3476John McCall 90023cba801e11b03929c44f8cf54578305963a3476John McCall if (CE->getCastKind() == CastExpr::CK_UncheckedDerivedToBase) 90123cba801e11b03929c44f8cf54578305963a3476John McCall return false; 902a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 903a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (isa<CXXThisExpr>(E)) { 904a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // We always assume that 'this' is never null. 905a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 906a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 907a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 908a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) { 909a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // And that lvalue casts are never null. 910a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (ICE->isLvalueCast()) 911a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 912a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 913a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 914a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return true; 915a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson} 916a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 917504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 918504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// have to handle a more broad range of conversions than explicit casts, as they 919504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// handle things like function to ptr-to-function decay etc. 920d888962cff03b543fbe9ac6051ec6addf5b993b4Eli FriedmanValue *ScalarExprEmitter::EmitCastExpr(CastExpr *CE) { 921d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Expr *E = CE->getSubExpr(); 922592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson QualType DestTy = CE->getType(); 923592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson CastExpr::CastKind Kind = CE->getCastKind(); 924592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson 925504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson if (!DestTy->isVoidType()) 926504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson TestAndClearIgnoreResultAssign(); 927db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 9288c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // Since almost all cast kinds apply to scalars, this switch doesn't have 9298c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // a default case, so the compiler will warn on a missing case. The cases 9308c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // are in the same order as in the CastKind enum. 931504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson switch (Kind) { 9327f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson case CastExpr::CK_Unknown: 933d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman // FIXME: All casts should have a known kind! 934ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman //assert(0 && "Unknown cast kind!"); 935504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson break; 936ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 93792ef5d75720c032808181133e4d7c5f82230237eFariborz Jahanian case CastExpr::CK_AnyPointerToObjCPointerCast: 9383b27f1a80e4e433b503efd344c909eeafaa9033cFariborz Jahanian case CastExpr::CK_AnyPointerToBlockPointerCast: 939cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson case CastExpr::CK_BitCast: { 940cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 941cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson return Builder.CreateBitCast(Src, ConvertType(DestTy)); 942cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson } 943ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_NoOp: 9440ddb6f7506d3bffe4e526f877d3ef48e8d942b1dAnders Carlsson case CastExpr::CK_UserDefinedConversion: 945ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Visit(const_cast<Expr*>(E)); 946db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 947a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson case CastExpr::CK_BaseToDerived: { 948a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const CXXRecordDecl *DerivedClassDecl = 949a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson DestTy->getCXXRecordDeclForPointerType(); 950a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 951a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl, 952a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson CE->getBasePath(), 953a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson ShouldNullCheckClassCastValue(CE)); 954a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 95523cba801e11b03929c44f8cf54578305963a3476John McCall case CastExpr::CK_UncheckedDerivedToBase: 956191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson case CastExpr::CK_DerivedToBase: { 957191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson const RecordType *DerivedClassTy = 958191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson E->getType()->getAs<PointerType>()->getPointeeType()->getAs<RecordType>(); 959191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson CXXRecordDecl *DerivedClassDecl = 960191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 961191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 96234a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, 96334a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson CE->getBasePath(), 96434a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson ShouldNullCheckClassCastValue(CE)); 965191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson } 9668c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_Dynamic: { 9678c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman Value *V = Visit(const_cast<Expr*>(E)); 9688c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE); 9698c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman return CGF.EmitDynamicCast(V, DCE); 9708c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman } 971d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman case CastExpr::CK_ToUnion: 972ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(0 && "Should be unreachable!"); 973ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman break; 974d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 975ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_ArrayToPointerDecay: { 976ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(E->getType()->isArrayType() && 977ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Array to pointer decay must have array source type!"); 978ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 979ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *V = EmitLValue(E).getAddress(); // Bitfields can't be arrays. 980ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 981ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Note that VLA pointers are always decayed, so we don't need to do 982ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // anything here. 983ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman if (!E->getType()->isVariableArrayType()) { 984ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 985ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 986ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman ->getElementType()) && 987ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Expected pointer to array"); 988ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman V = Builder.CreateStructGEP(V, 0, "arraydecay"); 989ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 990ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 991ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return V; 992ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 993ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_FunctionToPointerDecay: 994ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return EmitLValue(E).getAddress(); 995ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 996ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_NullToMemberPointer: 997ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return CGF.CGM.EmitNullConstant(DestTy); 998191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 9998c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_BaseToDerivedMemberPointer: 1000d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman case CastExpr::CK_DerivedToBaseMemberPointer: { 1001d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *Src = Visit(E); 1002d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 1003d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman // See if we need to adjust the pointer. 1004d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman const CXXRecordDecl *BaseDecl = 1005d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman cast<CXXRecordDecl>(E->getType()->getAs<MemberPointerType>()-> 1006d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman getClass()->getAs<RecordType>()->getDecl()); 1007d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman const CXXRecordDecl *DerivedDecl = 1008d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman cast<CXXRecordDecl>(CE->getType()->getAs<MemberPointerType>()-> 1009d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman getClass()->getAs<RecordType>()->getDecl()); 1010d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman if (CE->getCastKind() == CastExpr::CK_DerivedToBaseMemberPointer) 1011d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman std::swap(DerivedDecl, BaseDecl); 1012d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 1013bb7e17b52ffaa4097b4c4d7935746d23539ffe2aAnders Carlsson if (llvm::Constant *Adj = 1014e70ffd631179c15d358838464425e3464cf05a98Chris Lattner CGF.CGM.GetNonVirtualBaseClassOffset(DerivedDecl, CE->getBasePath())){ 1015d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman if (CE->getCastKind() == CastExpr::CK_DerivedToBaseMemberPointer) 1016e70ffd631179c15d358838464425e3464cf05a98Chris Lattner Src = Builder.CreateNSWSub(Src, Adj, "adj"); 1017d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman else 1018e70ffd631179c15d358838464425e3464cf05a98Chris Lattner Src = Builder.CreateNSWAdd(Src, Adj, "adj"); 1019d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 1020e70ffd631179c15d358838464425e3464cf05a98Chris Lattner 1021d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return Src; 1022d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 1023d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 10248c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_ConstructorConversion: 1025d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman assert(0 && "Should be unreachable!"); 10268c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman break; 10278c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman 10287f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson case CastExpr::CK_IntegralToPointer: { 10297f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 103082debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson 103182debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // First, convert to the correct width so that we control the kind of 103282debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // extension. 103382debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson const llvm::Type *MiddleTy = 103482debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson llvm::IntegerType::get(VMContext, CGF.LLVMPointerWidth); 103582debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson bool InputSigned = E->getType()->isSignedIntegerType(); 103682debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson llvm::Value* IntResult = 103782debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 103882debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson 103982debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy)); 10407f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 10417f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson case CastExpr::CK_PointerToIntegral: { 10427f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 10437f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson return Builder.CreatePtrToInt(Src, ConvertType(DestTy)); 10447f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 1045ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_ToVoid: { 1046ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman CGF.EmitAnyExpr(E, 0, false, true); 1047ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return 0; 1048ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1049ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_VectorSplat: { 1050ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman const llvm::Type *DstTy = ConvertType(DestTy); 1051ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *Elt = Visit(const_cast<Expr*>(E)); 1052ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1053ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Insert the element in element zero of an undef vector 1054ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *UnV = llvm::UndefValue::get(DstTy); 1055ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *Idx = 1056ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 0); 1057ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 1058ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1059ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Splat the element across to all elements 1060ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::SmallVector<llvm::Constant*, 16> Args; 1061ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 1062ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman for (unsigned i = 0; i < NumElements; i++) 1063ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Args.push_back(llvm::ConstantInt::get( 1064ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Type::getInt32Ty(VMContext), 0)); 1065ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1066ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 1067ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 1068ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Yay; 1069ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 10708c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_IntegralCast: 10718c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_IntegralToFloating: 10728c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_FloatingToIntegral: 10738c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_FloatingCast: 1074d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return EmitScalarConversion(Visit(E), E->getType(), DestTy); 1075ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 10763a1737030e3c8d209987325c61dacb8e4a65123bEli Friedman case CastExpr::CK_MemberPointerToBoolean: 10773a1737030e3c8d209987325c61dacb8e4a65123bEli Friedman return CGF.EvaluateExprAsBool(E); 1078e9776247577715ad3a19461769a3488a445a8cbdAnders Carlsson } 1079db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 108058a2e944faa16f1f61439acd2e71b19f50189511Chris Lattner // Handle cases where the source is an non-complex type. 1081db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 108219a1d7c646729eb858b15583e647262a22de3637Chris Lattner if (!CGF.hasAggregateLLVMType(E->getType())) { 10833707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner Value *Src = Visit(const_cast<Expr*>(E)); 10843707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 10853707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Use EmitScalarConversion to perform the conversion. 10863707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return EmitScalarConversion(Src, E->getType(), DestTy); 10873707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 1088db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10899b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (E->getType()->isAnyComplexType()) { 109019a1d7c646729eb858b15583e647262a22de3637Chris Lattner // Handle cases where the source is a complex type. 10917f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreImag = true; 10927f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreImagAssign = true; 10937f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreReal = IgnoreResultAssign; 10947f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreRealAssign = IgnoreResultAssign; 10957f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (DestTy->isBooleanType()) 10967f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreImagAssign = IgnoreImag = false; 10977f79f9be5916c51c35da4f126b7c12596a101607Mike Stump else if (DestTy->isVoidType()) { 10987f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreReal = IgnoreImag = false; 10997f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreRealAssign = IgnoreImagAssign = true; 11007f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } 11017f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CodeGenFunction::ComplexPairTy V 11027f79f9be5916c51c35da4f126b7c12596a101607Mike Stump = CGF.EmitComplexExpr(E, IgnoreReal, IgnoreImag, IgnoreRealAssign, 11037f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreImagAssign); 11047f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitComplexToScalarConversion(V, E->getType(), DestTy); 110519a1d7c646729eb858b15583e647262a22de3637Chris Lattner } 110610b00cfe6422906b223724048b9b2123968d3baaChris Lattner 110719a1d7c646729eb858b15583e647262a22de3637Chris Lattner // Okay, this is a cast from an aggregate. It must be a cast to void. Just 110819a1d7c646729eb858b15583e647262a22de3637Chris Lattner // evaluate the result and return. 11097f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitAggExpr(E, 0, false, true); 111019a1d7c646729eb858b15583e647262a22de3637Chris Lattner return 0; 11117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 11127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11133379320c10001d7e1ee5d7e7142c417f797cfe82Chris LattnerValue *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 111491d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner return CGF.EmitCompoundStmt(*E->getSubStmt(), 111591d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner !E->getType()->isVoidType()).getScalarVal(); 11163379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner} 11173379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 1118a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike StumpValue *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 1119f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian llvm::Value *V = CGF.GetAddrOfBlockDecl(E); 1120f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian if (E->getType().isObjCGCWeak()) 1121f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian return CGF.CGM.getObjCRuntime().EmitObjCWeakRead(CGF, V); 11222da84ff228a231adbd3f6f236b857f752d02959aDaniel Dunbar return Builder.CreateLoad(V, "tmp"); 11234e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump} 11243379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 11257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 11267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Unary Operators 11277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 11287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11298c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *ScalarExprEmitter:: 11308c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 11318c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 11328c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11338c11a65c18ae607b7073e1e451264492d2297726Chris Lattner QualType ValTy = E->getSubExpr()->getType(); 11348c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *InVal = EmitLoadOfLValue(LV, ValTy); 11358c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11368c11a65c18ae607b7073e1e451264492d2297726Chris Lattner int AmountVal = isInc ? 1 : -1; 11378c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11388c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (ValTy->isPointerType() && 11398c11a65c18ae607b7073e1e451264492d2297726Chris Lattner ValTy->getAs<PointerType>()->isVariableArrayType()) { 11408c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // The amount of the addition/subtraction needs to account for the VLA size 11418c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.ErrorUnsupported(E, "VLA pointer inc/dec"); 11428c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 11438c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11448c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *NextVal; 11458c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (const llvm::PointerType *PT = 11468c11a65c18ae607b7073e1e451264492d2297726Chris Lattner dyn_cast<llvm::PointerType>(InVal->getType())) { 11478c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Constant *Inc = 11488c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), AmountVal); 11498c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (!isa<llvm::FunctionType>(PT->getElementType())) { 11508c11a65c18ae607b7073e1e451264492d2297726Chris Lattner QualType PTEE = ValTy->getPointeeType(); 11518c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (const ObjCObjectType *OIT = PTEE->getAs<ObjCObjectType>()) { 11528c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Handle interface types, which are not represented with a concrete 11538c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // type. 11548c11a65c18ae607b7073e1e451264492d2297726Chris Lattner int size = CGF.getContext().getTypeSize(OIT) / 8; 11558c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (!isInc) 11568c11a65c18ae607b7073e1e451264492d2297726Chris Lattner size = -size; 11578c11a65c18ae607b7073e1e451264492d2297726Chris Lattner Inc = llvm::ConstantInt::get(Inc->getType(), size); 11588c11a65c18ae607b7073e1e451264492d2297726Chris Lattner const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 11598c11a65c18ae607b7073e1e451264492d2297726Chris Lattner InVal = Builder.CreateBitCast(InVal, i8Ty); 11608c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateGEP(InVal, Inc, "add.ptr"); 11618c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *lhs = LV.getAddress(); 11628c11a65c18ae607b7073e1e451264492d2297726Chris Lattner lhs = Builder.CreateBitCast(lhs, llvm::PointerType::getUnqual(i8Ty)); 11638c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LV = LValue::MakeAddr(lhs, CGF.MakeQualifiers(ValTy)); 11648c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else 11658c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateInBoundsGEP(InVal, Inc, "ptrincdec"); 11668c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 11678c11a65c18ae607b7073e1e451264492d2297726Chris Lattner const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 11688c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateBitCast(InVal, i8Ty, "tmp"); 11698c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateGEP(NextVal, Inc, "ptrincdec"); 11708c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateBitCast(NextVal, InVal->getType()); 11718c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 11728c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else if (InVal->getType()->isIntegerTy(1) && isInc) { 11738c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool++ is an interesting case, due to promotion rules, we get: 11748c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool++ -> Bool = Bool+1 -> Bool = (int)Bool+1 -> 11758c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool = ((int)Bool+1) != 0 11768c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // An interesting aspect of this is that increment is always true. 11778c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Decrement does not have this property. 11788c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantInt::getTrue(VMContext); 11798c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else if (isa<llvm::IntegerType>(InVal->getType())) { 11808c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal); 11818c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 1182640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner if (!ValTy->isSignedIntegerType()) 1183640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner // Unsigned integer inc is always two's complement. 11848c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1185640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner else { 1186640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1187640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Undefined: 1188640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner NextVal = Builder.CreateNSWAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1189640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner break; 1190640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Defined: 1191640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1192640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner break; 1193640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Trapping: 1194640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOpInfo BinOp; 1195640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.LHS = InVal; 1196640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.RHS = NextVal; 1197640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.Ty = E->getType(); 1198640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.Opcode = BinaryOperator::Add; 1199640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.E = E; 1200640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner return EmitOverflowCheckedBinOp(BinOp); 1201640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner } 1202640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner } 12038c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 12048c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Add the inc/dec to the real part. 12058c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (InVal->getType()->isFloatTy()) 12068c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = 12078c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::ConstantFP::get(VMContext, 12088c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat(static_cast<float>(AmountVal))); 12098c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else if (InVal->getType()->isDoubleTy()) 12108c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = 12118c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::ConstantFP::get(VMContext, 12128c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat(static_cast<double>(AmountVal))); 12138c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else { 12148c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat F(static_cast<float>(AmountVal)); 12158c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool ignored; 12168c11a65c18ae607b7073e1e451264492d2297726Chris Lattner F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 12178c11a65c18ae607b7073e1e451264492d2297726Chris Lattner &ignored); 12188c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantFP::get(VMContext, F); 12198c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 12208c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateFAdd(InVal, NextVal, isInc ? "inc" : "dec"); 12218c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 12228c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12238c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Store the updated result through the lvalue. 12248c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (LV.isBitField()) 12258c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.EmitStoreThroughBitfieldLValue(RValue::get(NextVal), LV, ValTy, &NextVal); 12268c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else 12278c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.EmitStoreThroughLValue(RValue::get(NextVal), LV, ValTy); 12288c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12298c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // If this is a postinc, return the value read from memory, otherwise use the 12308c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // updated value. 12318c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return isPre ? NextVal : InVal; 12328c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 12338c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12348c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12358c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 12377f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 12389a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Emit unary minus with EmitSub so we handle overflow cases etc. 12399a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOpInfo BinOp; 12409a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.RHS = Visit(E->getSubExpr());; 12419a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType()); 12429a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.Ty = E->getType(); 12439a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.Opcode = BinaryOperator::Sub; 12449a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.E = E; 12459a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner return EmitSub(BinOp); 12467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 12497f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 12507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 12517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNot(Op, "neg"); 12527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 12557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Compare operand to zero. 12567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 1257db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 12587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Invert value. 12597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // TODO: Could dynamically modify easy computations here. For example, if 12607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // the operand is an icmp ne, turn into icmp eq. 12617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BoolVal = Builder.CreateNot(BoolVal, "lnot"); 1262db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 12639f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson // ZExt result to the expr type. 12649f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext"); 12657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12678ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas GregorValue *ScalarExprEmitter::VisitOffsetOfExpr(const OffsetOfExpr *E) { 12688ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor Expr::EvalResult Result; 12698ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor if(E->Evaluate(Result, CGF.getContext())) 12708ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 12718ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 12728ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor // FIXME: Cannot support code generation for non-constant offsetof. 12738ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor unsigned DiagID = CGF.CGM.getDiags().getCustomDiagID(Diagnostic::Error, 12748ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor "cannot compile non-constant __builtin_offsetof"); 12758ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor CGF.CGM.getDiags().Report(CGF.getContext().getFullLoc(E->getLocStart()), 12768ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor DiagID) 12778ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor << E->getSourceRange(); 12788ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 12798ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor return llvm::Constant::getNullValue(ConvertType(E->getType())); 12808ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor} 12818ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 12820518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// VisitSizeOfAlignOfExpr - Return the size or alignment of the type of 12830518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// argument of the sizeof expression as an integer. 12840518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlValue * 12850518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) { 12860518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl QualType TypeToSize = E->getTypeOfArgument(); 1287f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isSizeOf()) { 1288db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (const VariableArrayType *VAT = 1289f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.getContext().getAsVariableArrayType(TypeToSize)) { 1290f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isArgumentType()) { 1291f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // sizeof(type) - make sure to emit the VLA size. 1292f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.EmitVLASize(TypeToSize); 12938f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman } else { 12948f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // C99 6.5.3.4p2: If the argument is an expression of type 12958f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // VLA, it is evaluated. 12968f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman CGF.EmitAnyExpr(E->getArgumentExpr()); 1297f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman } 1298db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 129996f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson return CGF.GetVLASize(VAT); 1300b50525ba0e996bc072cdb76152fcfe0bc64bb72aAnders Carlsson } 13015d46315ca3cbbfe0d0f5f65520b618fb05dd4446Anders Carlsson } 1302f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman 1303db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If this isn't sizeof(vla), the result must be constant; use the constant 1304db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // folding logic so we don't have to duplicate it here. 1305f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman Expr::EvalResult Result; 1306f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman E->Evaluate(Result, CGF.getContext()); 13074a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 13087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 131046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 131146f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 13129b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (Op->getType()->isAnyComplexType()) 13137f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return CGF.EmitComplexExpr(Op, false, true, false, true).first; 131446f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return Visit(Op); 131546f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 131646f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 131746f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 13189b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (Op->getType()->isAnyComplexType()) 13197f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return CGF.EmitComplexExpr(Op, true, false, true, false).second; 1320db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 13217f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __imag on a scalar returns zero. Emit the subexpr to ensure side 13227f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // effects are evaluated, but not the actual value. 13237f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (E->isLvalue(CGF.getContext()) == Expr::LV_Valid) 13247f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitLValue(Op); 13257f79f9be5916c51c35da4f126b7c12596a101607Mike Stump else 13267f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitScalarExpr(Op, true); 1327c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson return llvm::Constant::getNullValue(ConvertType(E->getType())); 132846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 132946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 13301eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpValue *ScalarExprEmitter::VisitUnaryOffsetOf(const UnaryOperator *E) { 133135183aca180a2b9b2c637cd625a40a7e147d6a32Eli Friedman Value* ResultAsPtr = EmitLValue(E->getSubExpr()).getAddress(); 1332769e411b72465a63454cdd416ff26ff313d43505Eli Friedman const llvm::Type* ResultType = ConvertType(E->getType()); 133335183aca180a2b9b2c637cd625a40a7e147d6a32Eli Friedman return Builder.CreatePtrToInt(ResultAsPtr, ResultType, "offsetof"); 13345a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 133546f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 13367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 13377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Binary Operators 13387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 13397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerBinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 13417f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 13427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BinOpInfo Result; 13437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.LHS = Visit(E->getLHS()); 13447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.RHS = Visit(E->getRHS()); 13451f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Result.Ty = E->getType(); 13469a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner Result.Opcode = E->getOpcode(); 13477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.E = E; 13487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Result; 13497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13516a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue ScalarExprEmitter::EmitCompoundAssignLValue( 13526a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E, 13536a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), 13546a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *&BitFieldResult) { 135554d76db0aa7107597cac0b80d8e138a37e6d1de9Benjamin Kramer QualType LHSTy = E->getLHS()->getType(); 13566a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor BitFieldResult = 0; 13571f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo OpInfo; 13586a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1359ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman if (E->getComputationResultType()->isAnyComplexType()) { 1360db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // This needs to go through the complex expression emitter, but it's a tad 1361db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // complicated to do that... I'm leaving it out for now. (Note that we do 1362db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // actually need the imaginary part of the RHS for multiplication and 1363db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // division.) 1364ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman CGF.ErrorUnsupported(E, "complex compound assignment"); 13656a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor llvm::UndefValue::get(CGF.ConvertType(E->getType())); 13666a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LValue(); 13671f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 13686a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1369cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // Emit the RHS first. __block variables need to have the rhs evaluated 1370cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // first, plus this should improve codegen a little. 1371cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.RHS = Visit(E->getRHS()); 1372cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.Ty = E->getComputationResultType(); 13739a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OpInfo.Opcode = E->getOpcode(); 1374cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.E = E; 1375ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // Load/convert the LHS. 1376b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHSLV = EmitCheckedLValue(E->getLHS()); 1377ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy); 1378ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 1379ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman E->getComputationLHSType()); 13806a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 13811f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Expand the binary operator. 13821f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *Result = (this->*Func)(OpInfo); 13836a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 13848c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Convert the result back to the LHS type. 1385ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 13866a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1387db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Store the result value into the LHS lvalue. Bit-fields are handled 1388db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // specially because the result is altered by the store, i.e., [C99 6.5.16p1] 1389db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // 'An assignment expression has the value of the left operand after the 1390db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // assignment...'. 1391f0fe5bc0e46038dc79cdd27fcf0c77ad4789fdffDaniel Dunbar if (LHSLV.isBitField()) { 13927f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (!LHSLV.isVolatileQualified()) { 13937f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy, 13947f79f9be5916c51c35da4f126b7c12596a101607Mike Stump &Result); 13956a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor BitFieldResult = Result; 13966a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LHSLV; 13977f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } else 13987f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy); 13997f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } else 1400ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy); 14016a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LHSLV; 14026a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 14036a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 14046a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorValue *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 14056a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 14066a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor bool Ignore = TestAndClearIgnoreResultAssign(); 14076a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *BitFieldResult; 14086a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor LValue LHSLV = EmitCompoundAssignLValue(E, Func, BitFieldResult); 14096a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor if (BitFieldResult) 14106a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return BitFieldResult; 14116a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 14127f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 14137f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 14147f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitLoadOfLValue(LHSLV, E->getType()); 14151f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner} 14161f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 14171f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 14187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 1419f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 14207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 14211f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner else if (Ops.Ty->isUnsignedIntegerType()) 14227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 14237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 14247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 14257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 14287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Rem in C can't be a floating point type: C99 6.5.5p2. 14291f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner if (Ops.Ty->isUnsignedIntegerType()) 14307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 14317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 14327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 14337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14352add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike StumpValue *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 14362add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned IID; 14372add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned OpID = 0; 14385d8b2cf9fd704f6ca5e33525803a65421c0b440eMike Stump 14399a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner switch (Ops.Opcode) { 1440035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Add: 1441035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::AddAssign: 1442035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 1; 1443035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::sadd_with_overflow; 1444035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1445035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Sub: 1446035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::SubAssign: 1447035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 2; 1448035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::ssub_with_overflow; 1449035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1450035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Mul: 1451035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::MulAssign: 1452035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 3; 1453035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::smul_with_overflow; 1454035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1455035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump default: 1456035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump assert(false && "Unsupported operation for overflow detection"); 1457ab4eff620a9ce0ea62cdf29529a66c2c98d116f5Daniel Dunbar IID = 0; 1458035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump } 1459035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID <<= 1; 1460035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID |= 1; 1461035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump 14622add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 14632add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 14642add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1); 14652add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 14662add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 14672add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 14682add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 14692add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 14702add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Branch in case of overflow. 14712add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::BasicBlock *initialBB = Builder.GetInsertBlock(); 14722add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::BasicBlock *overflowBB = 14732add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump CGF.createBasicBlock("overflow", CGF.CurFn); 14742add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::BasicBlock *continueBB = 14752add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump CGF.createBasicBlock("overflow.continue", CGF.CurFn); 14762add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 14772add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateCondBr(overflow, overflowBB, continueBB); 14782add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 14792add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Handle overflow 14802add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 14812add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(overflowBB); 14822add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 14832add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Handler is: 1484db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // long long *__overflow_handler)(long long a, long long b, char op, 14852add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // char width) 14862add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump std::vector<const llvm::Type*> handerArgTypes; 14870032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson handerArgTypes.push_back(llvm::Type::getInt64Ty(VMContext)); 14880032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson handerArgTypes.push_back(llvm::Type::getInt64Ty(VMContext)); 14890032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson handerArgTypes.push_back(llvm::Type::getInt8Ty(VMContext)); 14900032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson handerArgTypes.push_back(llvm::Type::getInt8Ty(VMContext)); 14910032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::FunctionType *handlerTy = llvm::FunctionType::get( 14920032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::Type::getInt64Ty(VMContext), handerArgTypes, false); 14932add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Value *handlerFunction = 14942add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump CGF.CGM.getModule().getOrInsertGlobal("__overflow_handler", 149596e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson llvm::PointerType::getUnqual(handlerTy)); 14962add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump handlerFunction = Builder.CreateLoad(handlerFunction); 14972add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 14982add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Value *handlerResult = Builder.CreateCall4(handlerFunction, 14990032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson Builder.CreateSExt(Ops.LHS, llvm::Type::getInt64Ty(VMContext)), 15000032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson Builder.CreateSExt(Ops.RHS, llvm::Type::getInt64Ty(VMContext)), 15010032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), OpID), 1502db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), 15032add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump cast<llvm::IntegerType>(opTy)->getBitWidth())); 15042add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 15052add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump handlerResult = Builder.CreateTrunc(handlerResult, opTy); 15062add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 15072add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateBr(continueBB); 1508db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 15092add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Set up the continuation 15102add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(continueBB); 15112add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Get the correct result 15122add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::PHINode *phi = Builder.CreatePHI(opTy); 15132add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump phi->reserveOperandSpace(2); 15142add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump phi->addIncoming(result, initialBB); 15152add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump phi->addIncoming(handlerResult, overflowBB); 15162add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 15172add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump return phi; 15182add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump} 15197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { 152158f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (!Ops.Ty->isAnyPointerType()) { 1522a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner if (Ops.Ty->isSignedIntegerType()) { 1523a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1524a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1525a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "add"); 1526a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1527a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 1528a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1529a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1530a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1531a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1532a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1533f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 153487415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFAdd(Ops.LHS, Ops.RHS, "add"); 1535bf933a0cb628670490c15367b3f5ccb3193354a7Dan Gohman 15367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 15372add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 1538daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 15397f215c12af4c3e7f81b24102a676aabfdb4e1566Chris Lattner // Must have binary (not unary) expr here. Unary pointer decrement doesn't 15409a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 15419a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 15429a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 154314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (Ops.Ty->isPointerType() && 15446217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek Ops.Ty->getAs<PointerType>()->isVariableArrayType()) { 1545daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size 15469a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer addition"); 1547daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 15489a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 15498f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Value *Ptr, *Idx; 15508f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Expr *IdxExp; 15519a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const PointerType *PT = BinOp->getLHS()->getType()->getAs<PointerType>(); 1552db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump const ObjCObjectPointerType *OPT = 15539a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<ObjCObjectPointerType>(); 155414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (PT || OPT) { 15558f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.LHS; 15568f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.RHS; 15579a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getRHS(); 155814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } else { // int + pointer 15599a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner PT = BinOp->getRHS()->getType()->getAs<PointerType>(); 15609a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OPT = BinOp->getRHS()->getType()->getAs<ObjCObjectPointerType>(); 156114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff assert((PT || OPT) && "Invalid add expr"); 15628f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.RHS; 15638f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.LHS; 15649a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getLHS(); 15658f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 15668f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner 15678f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 15687cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 15698f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // Zero or sign extend the pointer value based on whether the index is 15708f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // signed or not. 15710032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson const llvm::Type *IdxType = 15720032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::IntegerType::get(VMContext, CGF.LLVMPointerWidth); 15739619662a1d42e2008b865d3459c0677e149dad1bChris Lattner if (IdxExp->getType()->isSignedIntegerType()) 15748f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 15758f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner else 15768f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 15778f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 157814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType ElementType = PT ? PT->getPointeeType() : OPT->getPointeeType(); 1579db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1580c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = ElementType->getAs<ObjCObjectType>()) { 1581db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 15824a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1583199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext().getTypeSizeInChars(OIT).getQuantity()); 15842a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 15853c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 15862a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 15872a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 15882a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1589db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 15902a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1591db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Explicitly handle GNU void* and function pointer arithmetic extensions. The 1592db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // GNU void* casts amount to no-ops since our void* type is i8*, but this is 1593db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // future proof. 1594b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (ElementType->isVoidType() || ElementType->isFunctionType()) { 15953c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1596b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 15972a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 1598b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1599db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1600db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1601664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ptr, Idx, "add.ptr"); 16027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 16037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { 16052add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump if (!isa<llvm::PointerType>(Ops.LHS->getType())) { 1606a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner if (Ops.Ty->isSignedIntegerType()) { 1607a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1608a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1609a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub"); 1610a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1611a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 1612a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1613a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1614a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1615a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1616a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1617f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 161887415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFSub(Ops.LHS, Ops.RHS, "sub"); 16192eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner 16207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 16212add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 16221f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 16239a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Must have binary (not unary) expr here. Unary pointer increment doesn't 16249a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 16259a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 16269a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 16279a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner if (BinOp->getLHS()->getType()->isPointerType() && 16289a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<PointerType>()->isVariableArrayType()) { 1629daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size for 1630daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-int 1631daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the division needs to account for the VLA size for 1632daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-ptr. 16339a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer subtraction"); 1634daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 1635daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 16369a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const QualType LHSType = BinOp->getLHS()->getType(); 163714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType LHSElementType = LHSType->getPointeeType(); 16388c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar if (!isa<llvm::PointerType>(Ops.RHS->getType())) { 16398c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - int 16408c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *Idx = Ops.RHS; 16418c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 16427cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 16438c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Zero or sign extend the pointer value based on whether the index is 16448c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // signed or not. 16450032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson const llvm::Type *IdxType = 16460032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::IntegerType::get(VMContext, CGF.LLVMPointerWidth); 16479a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner if (BinOp->getRHS()->getType()->isSignedIntegerType()) 16488c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 16498c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar else 16508c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 16518c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 16528c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateNeg(Idx, "sub.ptr.neg"); 1653b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar 1654db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1655c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = LHSElementType->getAs<ObjCObjectType>()) { 1656db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 16574a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1658199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext(). 1659199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getTypeSizeInChars(OIT).getQuantity()); 16602a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 16613c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 16622a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 16632a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr"); 16642a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1665db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 16662a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1667b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // Explicitly handle GNU void* and function pointer arithmetic 1668db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // extensions. The GNU void* casts amount to no-ops since our void* type is 1669db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // i8*, but this is future proof. 1670b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 16713c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1672b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1673b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr"); 1674b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1675db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1676db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1677664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ops.LHS, Idx, "sub.ptr"); 1678820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar } else { 16798c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - pointer 16808c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *LHS = Ops.LHS; 16818c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *RHS = Ops.RHS; 1682db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1683199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ElementSize; 1684820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar 1685e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Handle GCC extension for pointer arithmetic on void* and function pointer 1686e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // types. 1687e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 1688199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CharUnits::One(); 16898c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } else { 1690199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CGF.getContext().getTypeSizeInChars(LHSElementType); 16918c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 1692db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 16938c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar const llvm::Type *ResultType = ConvertType(Ops.Ty); 16948c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); 16958c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 16968c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 1697db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1698e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Optimize out the shift for element size of 1. 1699199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck if (ElementSize.isOne()) 1700e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner return BytesBetween; 1701df1109434abd465a4db2e6f69ec2688866660367Dan Gohman 1702df1109434abd465a4db2e6f69ec2688866660367Dan Gohman // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 1703db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // pointer difference in C is only defined in the case where both operands 1704db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // are pointing to elements of an array. 1705199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck Value *BytesPerElt = 1706199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck llvm::ConstantInt::get(ResultType, ElementSize.getQuantity()); 1707df1109434abd465a4db2e6f69ec2688866660367Dan Gohman return Builder.CreateExactSDiv(BytesBetween, BytesPerElt, "sub.ptr.div"); 17087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 17097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 17127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 17137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 17147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 17157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 17167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1717db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1718be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 1719be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1720be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1721be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1722be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1723be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 172415037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 1725be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 1726be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 1727be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 17287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateShl(Ops.LHS, RHS, "shl"); 17297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 17327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 17337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 17347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 17357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 17367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1737db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1738be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 1739be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1740be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1741be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1742be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1743be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 174415037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 1745be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 1746be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 1747be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 17481f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner if (Ops.Ty->isUnsignedIntegerType()) 17497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 17507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 17517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 17547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc) { 17557f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 17564f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *Result; 17577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner QualType LHSTy = E->getLHS()->getType(); 1758b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman if (LHSTy->isMemberFunctionPointerType()) { 1759b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *LHSPtr = CGF.EmitAnyExprToTemp(E->getLHS()).getAggregateAddr(); 1760b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *RHSPtr = CGF.EmitAnyExprToTemp(E->getRHS()).getAggregateAddr(); 1761b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *LHSFunc = Builder.CreateStructGEP(LHSPtr, 0); 1762b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSFunc = Builder.CreateLoad(LHSFunc); 1763b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *RHSFunc = Builder.CreateStructGEP(RHSPtr, 0); 1764b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman RHSFunc = Builder.CreateLoad(RHSFunc); 1765b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *ResultF = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1766b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSFunc, RHSFunc, "cmp.func"); 1767b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *NullPtr = llvm::Constant::getNullValue(LHSFunc->getType()); 1768b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *ResultNull = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1769b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSFunc, NullPtr, "cmp.null"); 1770b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *LHSAdj = Builder.CreateStructGEP(LHSPtr, 1); 1771b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSAdj = Builder.CreateLoad(LHSAdj); 1772b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *RHSAdj = Builder.CreateStructGEP(RHSPtr, 1); 1773b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman RHSAdj = Builder.CreateLoad(RHSAdj); 1774b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *ResultA = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1775b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSAdj, RHSAdj, "cmp.adj"); 1776b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman if (E->getOpcode() == BinaryOperator::EQ) { 1777b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateOr(ResultNull, ResultA, "or.na"); 1778b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateAnd(Result, ResultF, "and.f"); 1779b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else { 1780b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman assert(E->getOpcode() == BinaryOperator::NE && 1781b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman "Member pointer comparison other than == or != ?"); 1782b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateAnd(ResultNull, ResultA, "and.na"); 1783b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateOr(Result, ResultF, "or.f"); 1784b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } 1785b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else if (!LHSTy->isAnyComplexType()) { 17867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS = Visit(E->getLHS()); 17877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 1788db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1789f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (LHS->getType()->isFPOrFPVectorTy()) { 17907a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 17917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 1792ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman } else if (LHSTy->isSignedIntegerType()) { 1793ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 17947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 17957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 1796ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman // Unsigned integers and pointers. 1797ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 17987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 17997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 18009c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner 18019c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // If this is a vector comparison, sign extend the result to the appropriate 18029c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // vector integer type and return it (don't convert to bool). 18039c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner if (LHSTy->isVectorType()) 18049c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 1805db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 18077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex Comparison: can only be an equality comparison. 18087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 18097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 1810db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1811183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType CETy = LHSTy->getAs<ComplexType>()->getElementType(); 1812db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18134f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *ResultR, *ResultI; 18147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (CETy->isRealFloatingType()) { 18157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 18167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 18177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 18187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 18197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 18207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex comparisons can only be equality comparisons. As such, signed 18217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // and unsigned opcodes are the same. 18227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 18237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 18247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 18257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 18267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1827db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getOpcode() == BinaryOperator::EQ) { 18297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 18307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 18317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E->getOpcode() == BinaryOperator::NE && 18327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Complex comparison other than == or != ?"); 18337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 18347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 18357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 183632f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes 183732f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 18387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 18397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 18407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 18417f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool Ignore = TestAndClearIgnoreResultAssign(); 18427f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 18437f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __block variables need to have the rhs evaluated first, plus this should 18447f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // improve codegen just a little. 18457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 1846b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHS = EmitCheckedLValue(E->getLHS()); 1847db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1848ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar // Store the value into the LHS. Bit-fields are handled specially 1849371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // because the result is altered by the store, i.e., [C99 6.5.16p1] 1850371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // 'An assignment expression has the value of the left operand after 1851daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // the assignment...'. 1852f0fe5bc0e46038dc79cdd27fcf0c77ad4789fdffDaniel Dunbar if (LHS.isBitField()) { 18537f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (!LHS.isVolatileQualified()) { 18547f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType(), 18557f79f9be5916c51c35da4f126b7c12596a101607Mike Stump &RHS); 18567f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return RHS; 18577f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } else 18587f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType()); 18597f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } else 1860ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType()); 18617f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 18627f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 18637f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitLoadOfLValue(LHS, E->getType()); 18647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 18657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 18667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 18677804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 18687804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 186920eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 187020eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 && X, just emit X without inserting the control flow. 187120eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 187220eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == 1) { // If we have 1 && X, just emit X. 18730946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 18747804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 18757804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 18760946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1877db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18787804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 187920eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 18807804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::Constant::getNullValue(ResTy); 18810946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1882db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18839615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 18849615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 188520eb09d562b80420a3328be789547af354bf3e36Chris Lattner 1886f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is false, go to the failure (cont) block. 1887f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 1888f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1889f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 1890f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be false. Start 1891f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 18920032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 18930032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 1894f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 1895f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 1896f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 18973b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 1898db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 189972119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 19007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 19017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 190272119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 1903db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 19057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 1906f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1907f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 1908f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 19097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 19107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 1911db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 19137804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 19147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 19177804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 19187804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 191920eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 192020eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 || X, just emit X without inserting the control flow. 192120eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 192220eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == -1) { // If we have 0 || X, just emit X. 19230946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 19247804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 19257804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 19260946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1927db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19287804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 192920eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 19307804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::ConstantInt::get(ResTy, 1); 19310946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1932db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19339615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 19349615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 1935db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1936f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is true, go to the success (cont) block. 1937f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 1938f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1939f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 1940f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be true. Start 1941f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 19420032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 19430032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 1944f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 1945f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 1946f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 19473b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 1948f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 194972119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 195033da07db112f4877f6ab13e20db08b9bb86a0c2eAnders Carlsson 1951f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit the RHS condition as a bool value. 19527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 19537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 1954db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 195572119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 1956db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 19587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 1959db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1960f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 1961f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 1962f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBlock(ContBlock); 19637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 1964db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 19667804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 19677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 19707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitStmt(E->getLHS()); 1971a448fb2da03ece39978784793eea68760e8205a1Daniel Dunbar CGF.EnsureInsertPoint(); 19727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getRHS()); 19737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 19767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Other Operators 19777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 19787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19799802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 19809802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// expression is cheap enough and side-effect-free enough to evaluate 19819802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// unconditionally instead of conditionally. This is used to convert control 19829802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// flow into selects in some cases. 1983df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stumpstatic bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 1984df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CodeGenFunction &CGF) { 19859802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) 1986df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr(), CGF); 1987db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19889802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // TODO: Allow anything we can constant fold to an integer or fp constant. 19899802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) || 19909802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner isa<FloatingLiteral>(E)) 19919802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 1992db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19939802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // Non-volatile automatic variables too, to get "cond ? X : Y" where 19949802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // X and Y are local variables. 19959802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 19969802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 1997df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (VD->hasLocalStorage() && !(CGF.getContext() 1998df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .getCanonicalType(VD->getType()) 1999df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .isVolatileQualified())) 20009802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2001db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20029802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return false; 20039802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner} 20049802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 20059802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 20067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter:: 20077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerVisitConditionalOperator(const ConditionalOperator *E) { 20087f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 200931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the condition constant folds and can be elided, try to avoid emitting 201031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the condition and the dead arm. 201131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getCond())){ 2012c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner Expr *Live = E->getLHS(), *Dead = E->getRHS(); 201331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (Cond == -1) 2014c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner std::swap(Live, Dead); 2015db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 201631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the dead side doesn't have labels we need, and if the Live side isn't 201731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the gnu missing ?: extension (which we could handle, but don't bother 201831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // to), just emit the Live part. 201931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if ((!Dead || !CGF.ContainsLabel(Dead)) && // No labels in dead part 202031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Live) // Live part isn't missing. 202131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return Visit(Live); 2022c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner } 2023db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2024db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20259802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // If this is a really simple expression (like x ? 4 : 5), emit this as a 20269802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // select instead of as control flow. We can only do this if it is cheap and 2027531a550531c144a58438f187816abbf1879e1c4eChris Lattner // safe to evaluate the LHS and RHS unconditionally. 2028df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (E->getLHS() && isCheapEnoughToEvaluateUnconditionally(E->getLHS(), 2029df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CGF) && 2030df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump isCheapEnoughToEvaluateUnconditionally(E->getRHS(), CGF)) { 20319802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *CondV = CGF.EvaluateExprAsBool(E->getCond()); 20329802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *LHS = Visit(E->getLHS()); 20339802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *RHS = Visit(E->getRHS()); 20349802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 20359802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner } 2036db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2037db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2038be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 2039be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 20409615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 2041035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Value *CondVal = 0; 2042035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner 2043db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If we don't have the GNU missing condition extension, emit a branch on bool 2044db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // the normal way. 204512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner if (E->getLHS()) { 204612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for 204712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the branch on bool. 204812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 204912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner } else { 205012d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, for the ?: extension, evaluate the conditional and then 205112d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // convert it to bool the hard way. We do this explicitly because we need 205212d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the unconverted value for the missing middle value of the ?:. 2053035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CondVal = CGF.EmitScalarExpr(E->getCond()); 2054db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 205512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // In some cases, EmitScalarConversion will delete the "CondVal" expression 205612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // if there are no extra uses (an optimization). Inhibit this by making an 205712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // extra dead use, because we're going to add a use of CondVal later. We 205812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // don't use the builder for this, because we don't want it to get optimized 205912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // away. This leaves dead code, but the ?: extension isn't common. 206012d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner new llvm::BitCastInst(CondVal, CondVal->getType(), "dummy?:holder", 206112d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner Builder.GetInsertBlock()); 2062db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2063035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Value *CondBoolVal = 2064035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.EmitScalarConversion(CondVal, E->getCond()->getType(), 2065035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.getContext().BoolTy); 2066035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock); 2067035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner } 2068fb6fa30a9b06670deb14f862dddbc49a12552939Anders Carlsson 206972119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 20707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(LHSBlock); 2071db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the GNU extension for missing LHS. 2073a21ddb30e56026967d58e26c5212744e1831305bChris Lattner Value *LHS; 2074a21ddb30e56026967d58e26c5212744e1831305bChris Lattner if (E->getLHS()) 2075856226c37ff10955c7f3f07ce6fa9522da23a3a5Eli Friedman LHS = Visit(E->getLHS()); 2076a21ddb30e56026967d58e26c5212744e1831305bChris Lattner else // Perform promotions, to handle cases like "short ?: int" 2077a21ddb30e56026967d58e26c5212744e1831305bChris Lattner LHS = EmitScalarConversion(CondVal, E->getCond()->getType(), E->getType()); 2078db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 207972119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 20807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHSBlock = Builder.GetInsertBlock(); 2081d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 2082db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 208372119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 20847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 2085db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2086856226c37ff10955c7f3f07ce6fa9522da23a3a5Eli Friedman Value *RHS = Visit(E->getRHS()); 208772119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 20887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2089d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 2090db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 2092db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 209348daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman // If the LHS or RHS is a throw expression, it will be legitimately null. 209448daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!LHS) 209548daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return RHS; 209648daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!RHS) 209748daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return LHS; 2098db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Create a PHI node for the real part. 21007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond"); 21017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->reserveOperandSpace(2); 21027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(LHS, LHSBlock); 21037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHS, RHSBlock); 21047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return PN; 21057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 21067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 21077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 21087976932a1c256d447316ffac58e9821417725e34Eli Friedman return Visit(E->getChosenSubExpr(CGF.getContext())); 21097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 21107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 21112202bce80fc72d067cbe67dc1512f7b45351fd31Chris LattnerValue *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 21124fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 2113ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 2114ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 2115ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson // If EmitVAArg fails, we fall back to the LLVM instruction. 2116db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (!ArgPtr) 2117ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 2118ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 21197f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // FIXME Volatility. 2120ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateLoad(ArgPtr); 21217c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson} 21227c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 2123df6b68c9487aed2042c7fc23db10a79f89083a11Mike StumpValue *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *BE) { 21240892099dbc640720400a1d9decd2733a09d733e5Mike Stump return CGF.BuildBlockLiteralTmp(BE); 2125df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump} 2126df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 21277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 21287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Entry Point into this File 21297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 21307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2131db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitScalarExpr - Emit the computation of the specified expression of scalar 2132db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type, ignoring the result. 21337f79f9be5916c51c35da4f126b7c12596a101607Mike StumpValue *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 21347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E && !hasAggregateLLVMType(E->getType()) && 21357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Invalid scalar expression to emit"); 2136db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21377f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return ScalarExprEmitter(*this, IgnoreResultAssign) 21387f79f9be5916c51c35da4f126b7c12596a101607Mike Stump .Visit(const_cast<Expr*>(E)); 21397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 21403707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 21413707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 21423707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 21434f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 21444f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 21453707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 21463707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner "Invalid scalar expression to emit"); 21473707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 21483707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 21494f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 2150db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 2151db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 2152db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 21534f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 21544f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, 21554f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 21569b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 21574f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner "Invalid complex -> scalar conversion"); 21584f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 21594f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner DstTy); 21604f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 2161cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 21628c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 21638c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *CodeGenFunction:: 21648c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 21658c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 21668c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre); 21678c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 21688c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2169820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz JahanianLValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 2170820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian llvm::Value *V; 2171820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // object->isa or (*object).isa 2172820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // Generate code as for: *(Class*)object 21735ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian // build Class* type 21745ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian const llvm::Type *ClassPtrTy = ConvertType(E->getType()); 21755ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian 2176820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Expr *BaseExpr = E->getBase(); 21775ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian if (BaseExpr->isLvalue(getContext()) != Expr::LV_Valid) { 21785ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = CreateTempAlloca(ClassPtrTy, "resval"); 21795ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian llvm::Value *Src = EmitScalarExpr(BaseExpr); 21805ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian Builder.CreateStore(Src, V); 21819f9efe6d58f49bce01b548bf81245f053b632a02Fariborz Jahanian LValue LV = LValue::MakeAddr(V, MakeQualifiers(E->getType())); 21829f9efe6d58f49bce01b548bf81245f053b632a02Fariborz Jahanian V = ScalarExprEmitter(*this).EmitLoadOfLValue(LV, E->getType()); 21835ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 21845ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian else { 21855ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian if (E->isArrow()) 21865ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr); 21875ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian else 21885ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = EmitLValue(BaseExpr).getAddress(); 21895ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 2190820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 2191820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // build Class* type 2192820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian ClassPtrTy = ClassPtrTy->getPointerTo(); 2193820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian V = Builder.CreateBitCast(V, ClassPtrTy); 2194820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian LValue LV = LValue::MakeAddr(V, MakeQualifiers(E->getType())); 2195820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian return LV; 2196820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian} 2197820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 21986a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 21996a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue CodeGenFunction::EmitCompoundAssignOperatorLValue( 22006a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E) { 22016a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor ScalarExprEmitter Scalar(*this); 22026a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *BitFieldResult = 0; 22036a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor switch (E->getOpcode()) { 22046a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#define COMPOUND_OP(Op) \ 22056a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Op##Assign: \ 22066a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 22076a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor BitFieldResult) 22086a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Mul); 22096a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Div); 22106a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Rem); 22116a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Add); 22126a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Sub); 22136a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shl); 22146a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shr); 22156a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(And); 22166a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Xor); 22176a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Or); 22186a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#undef COMPOUND_OP 22196a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 22206a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::PtrMemD: 22216a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::PtrMemI: 22226a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Mul: 22236a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Div: 22246a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Rem: 22256a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Add: 22266a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Sub: 22276a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Shl: 22286a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Shr: 22296a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LT: 22306a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::GT: 22316a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LE: 22326a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::GE: 22336a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::EQ: 22346a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::NE: 22356a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::And: 22366a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Xor: 22376a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Or: 22386a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LAnd: 22396a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LOr: 22406a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Assign: 22416a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Comma: 22426a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor assert(false && "Not valid compound assignment operators"); 22436a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor break; 22446a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor } 22456a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 22466a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor llvm_unreachable("Unhandled compound assignment operator"); 22476a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 2248