CGExprScalar.cpp revision 3f4cb120fe574f7b80864f52a1999502a4f3a83d
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. 437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner const BinaryOperator *E; 447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnernamespace { 4785b4521e34dcd4a0a4a1f0819e1123128e5a3125Benjamin Kramerclass ScalarExprEmitter 487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner : public StmtVisitor<ScalarExprEmitter, Value*> { 497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction &CGF; 5045d196b8387dcefc4df26cda114fa34c6528e928Daniel Dunbar CGBuilderTy &Builder; 517f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreResultAssign; 52a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson llvm::LLVMContext &VMContext; 537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerpublic: 547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 557f79f9be5916c51c35da4f126b7c12596a101607Mike Stump ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false) 56db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira), 57a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson VMContext(cgf.getLLVMContext()) { 587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 59db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Utilities 627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 647f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool TestAndClearIgnoreResultAssign() { 659c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner bool I = IgnoreResultAssign; 669c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner IgnoreResultAssign = false; 679c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return I; 689c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner } 697f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); } 717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); } 72b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue EmitCheckedLValue(const Expr *E) { return CGF.EmitCheckedLValue(E); } 737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(LValue LV, QualType T) { 759b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitLoadOfLValue(LV, T).getScalarVal(); 767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 77db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// EmitLoadOfLValue - Given an expression with complex type that represents a 797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// value l-value, this method emits the address of the l-value, then loads 807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// and returns the result. 817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(const Expr *E) { 82b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump return EmitLoadOfLValue(EmitCheckedLValue(E), E->getType()); 837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 84db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 859abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner /// EmitConversionToBool - Convert the specified expression value to a 863420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner /// boolean (i1) truth value. This is equivalent to "Val != 0". 879abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner Value *EmitConversionToBool(Value *Src, QualType DstTy); 88db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 893707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// EmitScalarConversion - Emit a conversion from the specified type to the 903707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// specified destination type, both of which are LLVM scalar types. 914f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy); 924f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 934f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner /// EmitComplexToScalarConversion - Emit a conversion from the specified 94db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump /// complex type to the specified destination type, where the destination type 95db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump /// is an LLVM scalar type. 964f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 974f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy); 98df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 99a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson /// EmitNullValue - Emit a value that corresponds to null for the given type. 100a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson Value *EmitNullValue(QualType Ty); 101a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 1027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 1037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Visitor Methods 1047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 1057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitStmt(Stmt *S) { 1077a9d49fd2bfac00e905b361ba76d26ab5b6c3b09Ted Kremenek S->dump(CGF.getContext().getSourceManager()); 1087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(0 && "Stmt can't have complex result type!"); 1097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 1107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitExpr(Expr *S); 112f51dc64f90851f636302dbaaf3f52c0524cdac36Fariborz Jahanian 1137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr()); } 1147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Leaves. 1167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitIntegerLiteral(const IntegerLiteral *E) { 1174a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(VMContext, E->getValue()); 1187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitFloatingLiteral(const FloatingLiteral *E) { 120bc0a2226c7fcd18b29b6846049e2cfcb872d3593Owen Anderson return llvm::ConstantFP::get(VMContext, E->getValue()); 1217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCharacterLiteral(const CharacterLiteral *E) { 1234a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 124e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman } 125e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 1264a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 1277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1287267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis Value *VisitCXXZeroInitValueExpr(const CXXZeroInitValueExpr *E) { 129a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1307267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis } 1313f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson Value *VisitGNUNullExpr(const GNUNullExpr *E) { 132a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1333f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson } 1347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) { 1354a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), 136ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff CGF.getContext().typesAreCompatible( 137ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff E->getArgType1(), E->getArgType2())); 1387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1398ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor Value *VisitOffsetOfExpr(const OffsetOfExpr *E); 1400518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl Value *VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E); 1410ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar Value *VisitAddrLabelExpr(const AddrLabelExpr *E) { 142d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel()); 143d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return Builder.CreateBitCast(V, ConvertType(E->getType())); 1440ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar } 145db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // l-values. 1477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitDeclRefExpr(DeclRefExpr *E) { 14828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 14928665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 15028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman assert(!Result.HasSideEffects && "Constant declref with side-effect?!"); 15128665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 15228665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 1537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 1547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 155db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 156db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCSelectorExpr(E); 1579c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 158db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 159db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCProtocolExpr(E); 1609c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 161db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 1629c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return EmitLoadOfLValue(E); 1639c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 1640a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 16585c59edda02df48fae8dc85049743319bc6e7e89Daniel Dunbar return EmitLoadOfLValue(E); 1669c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 16709105f52b1f28cbb1374c27c3c70f5517e2c465dFariborz Jahanian Value *VisitObjCImplicitSetterGetterRefExpr( 16809105f52b1f28cbb1374c27c3c70f5517e2c465dFariborz Jahanian ObjCImplicitSetterGetterRefExpr *E) { 16943f447098d5e6162fbfb97ed38365284207a7fbeFariborz Jahanian return EmitLoadOfLValue(E); 17043f447098d5e6162fbfb97ed38365284207a7fbeFariborz Jahanian } 1719c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar Value *VisitObjCMessageExpr(ObjCMessageExpr *E) { 1729c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return CGF.EmitObjCMessageExpr(E).getScalarVal(); 1730a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar } 1740a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar 17583dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian Value *VisitObjCIsaExpr(ObjCIsaExpr *E) { 176820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian LValue LV = CGF.EmitObjCIsaExpr(E); 177820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Value *V = CGF.EmitLoadOfLValue(LV, E->getType()).getScalarVal(); 17883dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian return V; 17983dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian } 18083dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian 1817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 182d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E); 18328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Value *VisitMemberExpr(MemberExpr *E); 184213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); } 185be20bb558cae5352898e6a913e29d24d20134841Chris Lattner Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 186be20bb558cae5352898e6a913e29d24d20134841Chris Lattner return EmitLoadOfLValue(E); 187be20bb558cae5352898e6a913e29d24d20134841Chris Lattner } 18835634f5ed67966c9f1fde38420e79cc6515cd673Devang Patel 1890533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *VisitInitListExpr(InitListExpr *E); 190db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1913498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) { 1923cb18bcefe39756f3b079fa1a62b4c9cbf6a592fAnders Carlsson return CGF.CGM.EmitNullConstant(E->getType()); 1933498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor } 194d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *VisitCastExpr(CastExpr *E) { 195c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman // Make sure to evaluate VLA bounds now so that we have them for later. 196c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman if (E->getType()->isVariablyModifiedType()) 197c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman CGF.EmitVLASize(E->getType()); 198c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman 199592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson return EmitCastExpr(E); 2007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 201d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *EmitCastExpr(CastExpr *E); 2027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCallExpr(const CallExpr *E) { 204e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson if (E->getCallReturnType()->isReferenceType()) 205e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson return EmitLoadOfLValue(E); 206db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2079b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitCallExpr(E).getScalarVal(); 2087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2098f2926b73ed635afecd020da787af6a837601a2bDaniel Dunbar 2103379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner Value *VisitStmtExpr(const StmtExpr *E); 2114e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump 212a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike Stump Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E); 213db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Unary Operators. 215dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner Value *VisitPrePostIncDec(const UnaryOperator *E, bool isInc, bool isPre) { 216dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner LValue LV = EmitLValue(E->getSubExpr()); 217dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner return CGF.EmitScalarPrePostIncDec(E, LV, isInc, isPre); 218dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner } 2197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostDec(const UnaryOperator *E) { 2207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return VisitPrePostIncDec(E, false, false); 2217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostInc(const UnaryOperator *E) { 2237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return VisitPrePostIncDec(E, true, false); 2247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreDec(const UnaryOperator *E) { 2267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return VisitPrePostIncDec(E, false, true); 2277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreInc(const UnaryOperator *E) { 2297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return VisitPrePostIncDec(E, true, true); 2307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryAddrOf(const UnaryOperator *E) { 2327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLValue(E->getSubExpr()).getAddress(); 2337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 2357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPlus(const UnaryOperator *E) { 2367f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // This differs from gcc, though, most likely due to a bug in gcc. 2377f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 2387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 2397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryMinus (const UnaryOperator *E); 2417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryNot (const UnaryOperator *E); 2427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryLNot (const UnaryOperator *E); 24346f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryReal (const UnaryOperator *E); 24446f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryImag (const UnaryOperator *E); 2457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryExtension(const UnaryOperator *E) { 2467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 2477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2485a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson Value *VisitUnaryOffsetOf(const UnaryOperator *E); 2498ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 2505f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson // C++ 25104421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 25204421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 25304421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 2545f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson Value *VisitCXXThisExpr(CXXThisExpr *TE) { 2555f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson return CGF.LoadCXXThis(); 256db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 257db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2587f6ad153565245026c7569314f65a4d4ff4ac41fAnders Carlsson Value *VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { 2593082463f4f387b725f4e4bf7d7b46269d445e4f5Anders Carlsson return CGF.EmitCXXExprWithTemporaries(E).getScalarVal(); 2607f6ad153565245026c7569314f65a4d4ff4ac41fAnders Carlsson } 261a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson Value *VisitCXXNewExpr(const CXXNewExpr *E) { 262a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson return CGF.EmitCXXNewExpr(E); 263a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson } 26460e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) { 26560e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson CGF.EmitCXXDeleteExpr(E); 26660e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson return 0; 26760e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson } 2689dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman Value *VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 2699dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman return llvm::ConstantInt::get(Builder.getInt1Ty(), 2709dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman E->EvaluateTrait(CGF.getContext())); 2719dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman } 272db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 273a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) { 274a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // C++ [expr.pseudo]p1: 275db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // The result shall only be used as the operand for the function call 276a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // operator (), and the result of such a call has type void. The only 277a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // effect is the evaluation of the postfix-expression before the dot or 278a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // arrow. 279a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor CGF.EmitScalarExpr(E->getBase()); 280a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor return 0; 281a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor } 282db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 283c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 284a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 285c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson } 286756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 287756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson Value *VisitCXXThrowExpr(const CXXThrowExpr *E) { 288756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson CGF.EmitCXXThrowExpr(E); 289756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson return 0; 290756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson } 291756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 2927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Binary Operators. 2937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitMul(const BinOpInfo &Ops) { 294035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump if (CGF.getContext().getLangOptions().OverflowChecking 295035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump && Ops.Ty->isSignedIntegerType()) 2962add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump return EmitOverflowCheckedBinOp(Ops); 297f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 29887415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul"); 2997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 3007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3012add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Create a binary op that checks for overflow. 3022add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Currently only supports +, - and *. 3032add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); 3047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitDiv(const BinOpInfo &Ops); 3057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitRem(const BinOpInfo &Ops); 3067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAdd(const BinOpInfo &Ops); 3077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitSub(const BinOpInfo &Ops); 3087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShl(const BinOpInfo &Ops); 3097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShr(const BinOpInfo &Ops); 3107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAnd(const BinOpInfo &Ops) { 3117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 3127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitXor(const BinOpInfo &Ops) { 3147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 3157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitOr (const BinOpInfo &Ops) { 3177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 3187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3201f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo EmitBinOps(const BinaryOperator *E); 3216a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 3226a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*F)(const BinOpInfo &), 3236a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *&BitFieldResult); 3246a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 3253ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *EmitCompoundAssign(const CompoundAssignOperator *E, 3261f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 3271f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 3281f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Binary operators and binary compound assignment operators. 3291f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#define HANDLEBINOP(OP) \ 3303ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP(const BinaryOperator *E) { \ 3313ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return Emit ## OP(EmitBinOps(E)); \ 3323ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner } \ 3333ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 3343ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 3351f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 3367177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Mul) 3377177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Div) 3387177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Rem) 3397177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Add) 3407177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Sub) 3417177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shl) 3427177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shr) 3437177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(And) 3447177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Xor) 3457177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Or) 3461f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#undef HANDLEBINOP 3478c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 3487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Comparisons. 3497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 3507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc); 3517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#define VISITCOMP(CODE, UI, SI, FP) \ 3527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBin##CODE(const BinaryOperator *E) { \ 3537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 3547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::FCmpInst::FP); } 3557177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT) 3567177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT) 3577177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE) 3587177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE) 3597177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ) 3607177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE) 3617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#undef VISITCOMP 362db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinAssign (const BinaryOperator *E); 3647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLAnd (const BinaryOperator *E); 3667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLOr (const BinaryOperator *E); 3677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinComma (const BinaryOperator *E); 3687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 36925b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); } 37025b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); } 37125b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman 3727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Other Operators. 373df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump Value *VisitBlockExpr(const BlockExpr *BE); 3747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitConditionalOperator(const ConditionalOperator *CO); 3757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitChooseExpr(ChooseExpr *CE); 3767c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson Value *VisitVAArgExpr(VAArgExpr *VE); 3777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 3787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return CGF.EmitObjCStringLiteral(E); 3797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 3817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} // end anonymous namespace. 3827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 3847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Utilities 3857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 3867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3879abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner/// EmitConversionToBool - Convert the specified expression value to a 3883420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner/// boolean (i1) truth value. This is equivalent to "Val != 0". 3899abc84e7ac4db891209fe67cc3a8c9690dc886efChris LattnerValue *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 390467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs"); 391db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3929abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner if (SrcType->isRealFloatingType()) { 3939abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Compare against 0.0 for fp scalars. 394c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 3959abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Builder.CreateFCmpUNE(Src, Zero, "tobool"); 3969abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 397db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 398237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson if (SrcType->isMemberPointerType()) { 399237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson // Compare against -1. 400237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson llvm::Value *NegativeOne = llvm::Constant::getAllOnesValue(Src->getType()); 401237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson return Builder.CreateICmpNE(Src, NegativeOne, "tobool"); 402237957c45774713f81fbd5394b3db4317fef0938Anders Carlsson } 403db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 404d1d66bcd6914ff82abdfa88dd25bb0b74cde3b99Daniel Dunbar assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 4059abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner "Unknown scalar type to convert"); 406db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4079abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Because of the type rules of C, we often end up computing a logical value, 4089abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // then zero extending it to int, then wanting it as a logical value again. 4099abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Optimize this common case. 4109abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(Src)) { 4110032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson if (ZI->getOperand(0)->getType() == 4120032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::Type::getInt1Ty(CGF.getLLVMContext())) { 4139abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner Value *Result = ZI->getOperand(0); 414356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // If there aren't any more uses, zap the instruction to save space. 415356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // Note that there can be more uses, for example if this 416356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // is the result of an assignment. 417356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman if (ZI->use_empty()) 418356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman ZI->eraseFromParent(); 4199abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Result; 4209abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 4219abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 422db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4239abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Compare against an integer or pointer null. 424c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 4259abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Builder.CreateICmpNE(Src, Zero, "tobool"); 4269abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner} 4279abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 4283707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 4293707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 4304f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 4314f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstType) { 4329619662a1d42e2008b865d3459c0677e149dad1bChris Lattner SrcType = CGF.getContext().getCanonicalType(SrcType); 4339619662a1d42e2008b865d3459c0677e149dad1bChris Lattner DstType = CGF.getContext().getCanonicalType(DstType); 4343707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (SrcType == DstType) return Src; 435db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 436cf289083ab007264fa3ea96d92f133339aee5d2dChris Lattner if (DstType->isVoidType()) return 0; 437db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4380032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::LLVMContext &VMContext = CGF.getLLVMContext(); 4393707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4403707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 441ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstType->isBooleanType()) 442ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return EmitConversionToBool(Src, SrcType); 443db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4443707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner const llvm::Type *DstTy = ConvertType(DstType); 4453707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4463707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Ignore conversions like int -> uint. 4473707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (Src->getType() == DstTy) 4483707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Src; 4493707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 450db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle pointer conversions next: pointers can only be converted to/from 451db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // other pointers and integers. Check for pointer types in terms of LLVM, as 452db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // some native types (like Obj-C id) may map to a pointer type. 453270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(DstTy)) { 4543707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // The source value may be an integer, or a pointer. 455191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson if (isa<llvm::PointerType>(Src->getType())) 4563707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Builder.CreateBitCast(Src, DstTy, "conv"); 457191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 4583707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 45925615424741bcce31fe52c896f76268f0307f00dEli Friedman // First, convert to the correct width so that we control the kind of 46025615424741bcce31fe52c896f76268f0307f00dEli Friedman // extension. 461db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump const llvm::Type *MiddleTy = 4620032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::IntegerType::get(VMContext, CGF.LLVMPointerWidth); 46325615424741bcce31fe52c896f76268f0307f00dEli Friedman bool InputSigned = SrcType->isSignedIntegerType(); 46425615424741bcce31fe52c896f76268f0307f00dEli Friedman llvm::Value* IntResult = 46525615424741bcce31fe52c896f76268f0307f00dEli Friedman Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 46625615424741bcce31fe52c896f76268f0307f00dEli Friedman // Then, cast to pointer. 46725615424741bcce31fe52c896f76268f0307f00dEli Friedman return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 4683707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 469db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 470270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(Src->getType())) { 4713707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Must be an ptr to int cast. 4723707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 47350b5a30db40322880340e957ad7d6d8d60bb4c5bAnders Carlsson return Builder.CreatePtrToInt(Src, DstTy, "conv"); 4743707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 475db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 476213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // A scalar can be splatted to an extended vector of the same element type 4772ef13e5abef0570a9f567b4671367275c05d4d34Nate Begeman if (DstType->isExtVectorType() && !SrcType->isVectorType()) { 4786fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Cast the scalar to element type 479183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType EltTy = DstType->getAs<ExtVectorType>()->getElementType(); 4806fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 4816fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 4826fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Insert the element in element zero of an undef vector 48303e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::Value *UnV = llvm::UndefValue::get(DstTy); 4840032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::Value *Idx = 4850032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 0); 4866fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 4876fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 4886fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Splat the element across to all elements 4896fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 4906fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 4916fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman for (unsigned i = 0; i < NumElements; i++) 4920032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson Args.push_back(llvm::ConstantInt::get( 4930032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::Type::getInt32Ty(VMContext), 0)); 494db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4954a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 4966fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 4976fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman return Yay; 4986fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman } 4994119d1aeca8016654d381ce079864058d1709571Nate Begeman 5003b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner // Allow bitcast from vector to integer/fp of the same size. 5017019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson if (isa<llvm::VectorType>(Src->getType()) || 5023b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner isa<llvm::VectorType>(DstTy)) 5037019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson return Builder.CreateBitCast(Src, DstTy, "conv"); 504db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5053707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Finally, we have the arithmetic types: real int/float. 5063707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(Src->getType())) { 5073707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner bool InputSigned = SrcType->isSignedIntegerType(); 508b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (isa<llvm::IntegerType>(DstTy)) 509b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 510b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else if (InputSigned) 511b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateSIToFP(Src, DstTy, "conv"); 512b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 513b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateUIToFP(Src, DstTy, "conv"); 5143707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 515db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 516f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(Src->getType()->isFloatingPointTy() && "Unknown real conversion"); 5173707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(DstTy)) { 518b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstType->isSignedIntegerType()) 519b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToSI(Src, DstTy, "conv"); 520b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 521b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToUI(Src, DstTy, "conv"); 5223707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 5233707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 524f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(DstTy->isFloatingPointTy() && "Unknown real conversion"); 525b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstTy->getTypeID() < Src->getType()->getTypeID()) 526b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPTrunc(Src, DstTy, "conv"); 527b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 528b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPExt(Src, DstTy, "conv"); 5293707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 5303707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 531db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 532db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 533db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 5344f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter:: 5354f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerEmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 5364f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy) { 537ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Get the source element type. 538183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall SrcTy = SrcTy->getAs<ComplexType>()->getElementType(); 539db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 540ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 541ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstTy->isBooleanType()) { 542ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Complex != 0 -> (Real != 0) | (Imag != 0) 543ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 544ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 545ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return Builder.CreateOr(Src.first, Src.second, "tobool"); 546ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner } 547db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5484f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 5494f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // the imaginary part of the complex value is discarded and the value of the 5504f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // real part is converted according to the conversion rules for the 551db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // corresponding real type. 5524f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return EmitScalarConversion(Src.first, SrcTy, DstTy); 5534f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 5544f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 555a40a9f31218c743e366322e34b59f0d4d4414198Anders CarlssonValue *ScalarExprEmitter::EmitNullValue(QualType Ty) { 556a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson const llvm::Type *LTy = ConvertType(Ty); 557a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 558a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson if (!Ty->isMemberPointerType()) 559a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return llvm::Constant::getNullValue(LTy); 560a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 561a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson assert(!Ty->isMemberFunctionPointerType() && 562a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson "member function pointers are not scalar!"); 563a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 564a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson // Itanium C++ ABI 2.3: 565a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson // A NULL pointer is represented as -1. 566a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return llvm::ConstantInt::get(LTy, -1ULL, /*isSigned=*/true); 567a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson} 5684f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 5697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Visitor Methods 5717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitExpr(Expr *E) { 574488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGF.ErrorUnsupported(E, "scalar expression"); 5757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getType()->isVoidType()) 5767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 57703e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 5787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 5797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 580d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanValue *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 58137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Vector Mask Case 58237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 2 || 5833f4cb120fe574f7b80864f52a1999502a4f3a83dRafael Espindola (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { 58437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* LHS = CGF.EmitScalarExpr(E->getExpr(0)); 58537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* RHS = CGF.EmitScalarExpr(E->getExpr(1)); 58637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* Mask; 58737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 58837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::Type *I32Ty = llvm::Type::getInt32Ty(CGF.getLLVMContext()); 58937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType()); 59037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman unsigned LHSElts = LTy->getNumElements(); 59137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 59237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 3) { 59337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = CGF.EmitScalarExpr(E->getExpr(2)); 59437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 59537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Shuffle LHS & RHS into one input vector. 59637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> concat; 59737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0; i != LHSElts; ++i) { 59837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman concat.push_back(llvm::ConstantInt::get(I32Ty, 2*i)); 59937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman concat.push_back(llvm::ConstantInt::get(I32Ty, 2*i+1)); 60037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 60137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 60237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* CV = llvm::ConstantVector::get(concat.begin(), concat.size()); 60337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); 60437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHSElts *= 2; 60537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } else { 60637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = RHS; 60737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 60837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 60937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType()); 61037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant* EltMask; 61137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 61237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Treat vec3 like vec4. 61337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) 61437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 61537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+2))-1); 61637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else if ((LHSElts == 3) && (E->getNumSubExprs() == 2)) 61737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 61837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+1))-1); 61937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else 62037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 62137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts))-1); 62237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 62337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Mask off the high bits of each shuffle index. 62437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant *, 32> MaskV; 62537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) 62637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MaskV.push_back(EltMask); 62737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 62837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* MaskBits = llvm::ConstantVector::get(MaskV.begin(), MaskV.size()); 62937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); 63037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 63137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = undef 63237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // mask = mask & maskbits 63337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // for each elt 63437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // n = extract mask i 63537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // x = extract val n 63637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = insert newv, x, i 63737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(), 63837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MTy->getNumElements()); 63937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* NewV = llvm::UndefValue::get(RTy); 64037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) { 64137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *Indx = llvm::ConstantInt::get(I32Ty, i); 64237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateExtractElement(Mask, Indx, "shuf_idx"); 64337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateZExt(Indx, I32Ty, "idx_zext"); 64437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 64537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 64637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { 64737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *cmpIndx, *newIndx; 64837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman cmpIndx = Builder.CreateICmpUGT(Indx, llvm::ConstantInt::get(I32Ty, 3), 64937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "cmp_shuf_idx"); 65037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman newIndx = Builder.CreateSub(Indx, llvm::ConstantInt::get(I32Ty, 1), 65137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "shuf_idx_adj"); 65237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx"); 65337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 65437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt"); 65537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman NewV = Builder.CreateInsertElement(NewV, VExt, Indx, "shuf_ins"); 65637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 65737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman return NewV; 658d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 65937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 660d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 661d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 66237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 66337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 66437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> indices; 66537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 66637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant *C = cast<llvm::Constant>(CGF.EmitScalarExpr(E->getExpr(i))); 66737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *VTy = cast<llvm::VectorType>(V1->getType()); 66837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (VTy->getNumElements() == 3) { 66937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C)) { 67037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman uint64_t cVal = CI->getZExtValue(); 67137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (cVal > 3) { 67237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman C = llvm::ConstantInt::get(C->getType(), cVal-1); 67337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 67437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 67537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 67637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman indices.push_back(C); 67737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 67837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 6794a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson Value* SV = llvm::ConstantVector::get(indices.begin(), indices.size()); 680d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 681d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 68228665272c36cccb1014a6ea1217354b0519e2b59Eli FriedmanValue *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) { 68328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 68428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 68528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->isArrow()) 68628665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman CGF.EmitScalarExpr(E->getBase()); 68728665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman else 68828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman EmitLValue(E->getBase()); 68928665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 69028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 69128665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return EmitLoadOfLValue(E); 69228665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman} 693d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 6947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 6957f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 6967f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 6977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Emit subscript expressions in rvalue context's. For most cases, this just 6987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // loads the lvalue formed by the subscript expr. However, we have to be 6997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // careful, because the base of a vector subscript is occasionally an rvalue, 7007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // so we can't get it as an lvalue. 7017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (!E->getBase()->getType()->isVectorType()) 7027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 703db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 7047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the vector case. The base must be a vector, the index must be an 7057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // integer value. 7067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Base = Visit(E->getBase()); 7077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Idx = Visit(E->getIdx()); 708daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman bool IdxSigned = E->getIdx()->getType()->isSignedIntegerType(); 7090032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson Idx = Builder.CreateIntCast(Idx, 710db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Type::getInt32Ty(CGF.getLLVMContext()), 7110032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson IdxSigned, 712515ff5a31d75df9f4f099458a31cd7a405cf513dEli Friedman "vecidxcast"); 7137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateExtractElement(Base, Idx, "vecext"); 7147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 7157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7160533b3020ca39898751d4200feed776861dcd1ceNate Begemanstatic llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, 7170533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned Off, const llvm::Type *I32Ty) { 7180533b3020ca39898751d4200feed776861dcd1ceNate Begeman int MV = SVI->getMaskValue(Idx); 7190533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (MV == -1) 7200533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::UndefValue::get(I32Ty); 7210533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::ConstantInt::get(I32Ty, Off+MV); 7220533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 7230533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7240533b3020ca39898751d4200feed776861dcd1ceNate BegemanValue *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { 7250533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool Ignore = TestAndClearIgnoreResultAssign(); 7260533b3020ca39898751d4200feed776861dcd1ceNate Begeman (void)Ignore; 7270533b3020ca39898751d4200feed776861dcd1ceNate Begeman assert (Ignore == false && "init list ignored"); 7280533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned NumInitElements = E->getNumInits(); 7290533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7300533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (E->hadArrayRangeDesignator()) 7310533b3020ca39898751d4200feed776861dcd1ceNate Begeman CGF.ErrorUnsupported(E, "GNU array range designator extension"); 7320533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7330533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VType = 7340533b3020ca39898751d4200feed776861dcd1ceNate Begeman dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 7350533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7360533b3020ca39898751d4200feed776861dcd1ceNate Begeman // We have a scalar in braces. Just use the first element. 7370533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VType) 7380533b3020ca39898751d4200feed776861dcd1ceNate Begeman return Visit(E->getInit(0)); 7390533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7400533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned ResElts = VType->getNumElements(); 7410533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::Type *I32Ty = llvm::Type::getInt32Ty(CGF.getLLVMContext()); 7420533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7430533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Loop over initializers collecting the Value for each, and remembering 7440533b3020ca39898751d4200feed776861dcd1ceNate Begeman // whether the source was swizzle (ExtVectorElementExpr). This will allow 7450533b3020ca39898751d4200feed776861dcd1ceNate Begeman // us to fold the shuffle for the swizzle into the shuffle for the vector 7460533b3020ca39898751d4200feed776861dcd1ceNate Begeman // initializer, since LLVM optimizers generally do not want to touch 7470533b3020ca39898751d4200feed776861dcd1ceNate Begeman // shuffles. 7480533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned CurIdx = 0; 7490533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool VIsUndefShuffle = false; 7500533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *V = llvm::UndefValue::get(VType); 7510533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned i = 0; i != NumInitElements; ++i) { 7520533b3020ca39898751d4200feed776861dcd1ceNate Begeman Expr *IE = E->getInit(i); 7530533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Init = Visit(IE); 7540533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 7550533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7560533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType()); 7570533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7580533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Handle scalar elements. If the scalar initializer is actually one 7590533b3020ca39898751d4200feed776861dcd1ceNate Begeman // element of a different vector of the same width, use shuffle instead of 7600533b3020ca39898751d4200feed776861dcd1ceNate Begeman // extract+insert. 7610533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VVT) { 7620533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 7630533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init); 7640533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7650533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (EI->getVectorOperandType()->getNumElements() == ResElts) { 7660533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand()); 7670533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *LHS = 0, *RHS = 0; 7680533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) { 7690533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undef -> shuffle (src, undef) 7700533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(C); 7710533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 1; j != ResElts; ++j) 7720533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::UndefValue::get(I32Ty)); 7730533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7740533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = EI->getVectorOperand(); 7750533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = V; 7760533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = true; 7770533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else if (VIsUndefShuffle) { 7780533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undefshuffle && size match -> shuffle (v, src) 7790533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V); 7800533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 7810533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(SVV, j, 0, I32Ty)); 7820533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::ConstantInt::get(I32Ty, 7830533b3020ca39898751d4200feed776861dcd1ceNate Begeman ResElts + C->getZExtValue())); 7840533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + 1; j != ResElts; ++j) 7850533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::UndefValue::get(I32Ty)); 7860533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7870533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 7880533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = EI->getVectorOperand(); 7890533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 7900533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 7910533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!Args.empty()) { 7920533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 7930533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(LHS, RHS, Mask); 7940533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 7950533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 7960533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 7970533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 7980533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 7990533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Idx = llvm::ConstantInt::get(I32Ty, CurIdx); 8000533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 8010533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8020533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8030533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8040533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8050533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8060533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned InitElts = VVT->getNumElements(); 8070533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8080533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's 8090533b3020ca39898751d4200feed776861dcd1ceNate Begeman // input is the same width as the vector being constructed, generate an 8100533b3020ca39898751d4200feed776861dcd1ceNate Begeman // optimized shuffle of the swizzle input into the result. 811a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman unsigned Offset = (CurIdx == 0) ? 0 : ResElts; 8120533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 8130533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init); 8140533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *SVOp = SVI->getOperand(0); 8150533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType()); 8160533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8170533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (OpTy->getNumElements() == ResElts) { 8180533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) { 8190533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the current vector initializer is a shuffle with undef, merge 8200533b3020ca39898751d4200feed776861dcd1ceNate Begeman // this shuffle directly into it. 8210533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) { 8220533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0, 8230533b3020ca39898751d4200feed776861dcd1ceNate Begeman I32Ty)); 8240533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else { 8250533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::ConstantInt::get(I32Ty, j)); 8260533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8270533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8280533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0, je = InitElts; j != je; ++j) 8290533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(SVI, j, Offset, I32Ty)); 8300533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 8310533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::UndefValue::get(I32Ty)); 8320533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8330533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) 8340533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 8350533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8360533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = SVOp; 8370533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8380533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8390533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8400533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Extend init to result vector length, and then shuffle its contribution 8410533b3020ca39898751d4200feed776861dcd1ceNate Begeman // to the vector initializer into V. 8420533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (Args.empty()) { 8430533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 8440533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::ConstantInt::get(I32Ty, j)); 8450533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = InitElts; j != ResElts; ++j) 8460533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::UndefValue::get(I32Ty)); 8470533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 8480533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), 849a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman Mask, "vext"); 8500533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8510533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.clear(); 8520533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 8530533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::ConstantInt::get(I32Ty, j)); 8540533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 855a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman Args.push_back(llvm::ConstantInt::get(I32Ty, j+Offset)); 8560533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 8570533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(llvm::UndefValue::get(I32Ty)); 8580533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8590533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8600533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If V is undef, make sure it ends up on the RHS of the shuffle to aid 8610533b3020ca39898751d4200feed776861dcd1ceNate Begeman // merging subsequent shuffles into this one. 8620533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) 8630533b3020ca39898751d4200feed776861dcd1ceNate Begeman std::swap(V, Init); 8640533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 8650533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit"); 8660533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = isa<llvm::UndefValue>(Init); 8670533b3020ca39898751d4200feed776861dcd1ceNate Begeman CurIdx += InitElts; 8680533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8690533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8700533b3020ca39898751d4200feed776861dcd1ceNate Begeman // FIXME: evaluate codegen vs. shuffling against constant null vector. 8710533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers. 8720533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::Type *EltTy = VType->getElementType(); 8730533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8740533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers 8750533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { 8760533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Idx = llvm::ConstantInt::get(I32Ty, CurIdx); 8770533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *Init = llvm::Constant::getNullValue(EltTy); 8780533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 8790533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8800533b3020ca39898751d4200feed776861dcd1ceNate Begeman return V; 8810533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 8820533b3020ca39898751d4200feed776861dcd1ceNate Begeman 883a3697c9c155bda93fd2802f37084b620f4738822Anders Carlssonstatic bool ShouldNullCheckClassCastValue(const CastExpr *CE) { 884a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const Expr *E = CE->getSubExpr(); 88523cba801e11b03929c44f8cf54578305963a3476John McCall 88623cba801e11b03929c44f8cf54578305963a3476John McCall if (CE->getCastKind() == CastExpr::CK_UncheckedDerivedToBase) 88723cba801e11b03929c44f8cf54578305963a3476John McCall return false; 888a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 889a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (isa<CXXThisExpr>(E)) { 890a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // We always assume that 'this' is never null. 891a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 892a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 893a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 894a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) { 895a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // And that lvalue casts are never null. 896a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (ICE->isLvalueCast()) 897a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 898a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 899a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 900a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return true; 901a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson} 902a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 903504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 904504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// have to handle a more broad range of conversions than explicit casts, as they 905504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// handle things like function to ptr-to-function decay etc. 906d888962cff03b543fbe9ac6051ec6addf5b993b4Eli FriedmanValue *ScalarExprEmitter::EmitCastExpr(CastExpr *CE) { 907d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Expr *E = CE->getSubExpr(); 908592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson QualType DestTy = CE->getType(); 909592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson CastExpr::CastKind Kind = CE->getCastKind(); 910592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson 911504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson if (!DestTy->isVoidType()) 912504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson TestAndClearIgnoreResultAssign(); 913db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 9148c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // Since almost all cast kinds apply to scalars, this switch doesn't have 9158c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // a default case, so the compiler will warn on a missing case. The cases 9168c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // are in the same order as in the CastKind enum. 917504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson switch (Kind) { 9187f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson case CastExpr::CK_Unknown: 919d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman // FIXME: All casts should have a known kind! 920ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman //assert(0 && "Unknown cast kind!"); 921504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson break; 922ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 92392ef5d75720c032808181133e4d7c5f82230237eFariborz Jahanian case CastExpr::CK_AnyPointerToObjCPointerCast: 9243b27f1a80e4e433b503efd344c909eeafaa9033cFariborz Jahanian case CastExpr::CK_AnyPointerToBlockPointerCast: 925cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson case CastExpr::CK_BitCast: { 926cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 927cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson return Builder.CreateBitCast(Src, ConvertType(DestTy)); 928cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson } 929ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_NoOp: 9300ddb6f7506d3bffe4e526f877d3ef48e8d942b1dAnders Carlsson case CastExpr::CK_UserDefinedConversion: 931ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Visit(const_cast<Expr*>(E)); 932db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 933a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson case CastExpr::CK_BaseToDerived: { 934a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const CXXRecordDecl *DerivedClassDecl = 935a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson DestTy->getCXXRecordDeclForPointerType(); 936a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 937a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl, 938a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson CE->getBasePath(), 939a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson ShouldNullCheckClassCastValue(CE)); 940a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 94123cba801e11b03929c44f8cf54578305963a3476John McCall case CastExpr::CK_UncheckedDerivedToBase: 942191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson case CastExpr::CK_DerivedToBase: { 943191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson const RecordType *DerivedClassTy = 944191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson E->getType()->getAs<PointerType>()->getPointeeType()->getAs<RecordType>(); 945191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson CXXRecordDecl *DerivedClassDecl = 946191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 947191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 94834a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, 94934a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson CE->getBasePath(), 95034a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson ShouldNullCheckClassCastValue(CE)); 951191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson } 9528c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_Dynamic: { 9538c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman Value *V = Visit(const_cast<Expr*>(E)); 9548c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE); 9558c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman return CGF.EmitDynamicCast(V, DCE); 9568c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman } 957d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman case CastExpr::CK_ToUnion: 958ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(0 && "Should be unreachable!"); 959ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman break; 960d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 961ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_ArrayToPointerDecay: { 962ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(E->getType()->isArrayType() && 963ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Array to pointer decay must have array source type!"); 964ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 965ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *V = EmitLValue(E).getAddress(); // Bitfields can't be arrays. 966ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 967ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Note that VLA pointers are always decayed, so we don't need to do 968ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // anything here. 969ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman if (!E->getType()->isVariableArrayType()) { 970ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 971ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 972ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman ->getElementType()) && 973ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Expected pointer to array"); 974ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman V = Builder.CreateStructGEP(V, 0, "arraydecay"); 975ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 976ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 977ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return V; 978ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 979ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_FunctionToPointerDecay: 980ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return EmitLValue(E).getAddress(); 981ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 982ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_NullToMemberPointer: 983ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return CGF.CGM.EmitNullConstant(DestTy); 984191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 9858c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_BaseToDerivedMemberPointer: 986d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman case CastExpr::CK_DerivedToBaseMemberPointer: { 987d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *Src = Visit(E); 988d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 989d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman // See if we need to adjust the pointer. 990d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman const CXXRecordDecl *BaseDecl = 991d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman cast<CXXRecordDecl>(E->getType()->getAs<MemberPointerType>()-> 992d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman getClass()->getAs<RecordType>()->getDecl()); 993d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman const CXXRecordDecl *DerivedDecl = 994d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman cast<CXXRecordDecl>(CE->getType()->getAs<MemberPointerType>()-> 995d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman getClass()->getAs<RecordType>()->getDecl()); 996d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman if (CE->getCastKind() == CastExpr::CK_DerivedToBaseMemberPointer) 997d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman std::swap(DerivedDecl, BaseDecl); 998d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 999bb7e17b52ffaa4097b4c4d7935746d23539ffe2aAnders Carlsson if (llvm::Constant *Adj = 1000e04d45e05277ee04997fe59b1d194503f484c846Anders Carlsson CGF.CGM.GetNonVirtualBaseClassOffset(DerivedDecl, 1001e04d45e05277ee04997fe59b1d194503f484c846Anders Carlsson CE->getBasePath())) { 1002d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman if (CE->getCastKind() == CastExpr::CK_DerivedToBaseMemberPointer) 1003d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Src = Builder.CreateSub(Src, Adj, "adj"); 1004d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman else 1005d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Src = Builder.CreateAdd(Src, Adj, "adj"); 1006d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 1007d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return Src; 1008d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 1009d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 10108c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_ConstructorConversion: 1011d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman assert(0 && "Should be unreachable!"); 10128c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman break; 10138c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman 10147f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson case CastExpr::CK_IntegralToPointer: { 10157f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 101682debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson 101782debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // First, convert to the correct width so that we control the kind of 101882debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // extension. 101982debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson const llvm::Type *MiddleTy = 102082debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson llvm::IntegerType::get(VMContext, CGF.LLVMPointerWidth); 102182debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson bool InputSigned = E->getType()->isSignedIntegerType(); 102282debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson llvm::Value* IntResult = 102382debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 102482debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson 102582debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy)); 10267f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 10277f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson case CastExpr::CK_PointerToIntegral: { 10287f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 10297f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson return Builder.CreatePtrToInt(Src, ConvertType(DestTy)); 10307f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 1031ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_ToVoid: { 1032ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman CGF.EmitAnyExpr(E, 0, false, true); 1033ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return 0; 1034ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1035ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman case CastExpr::CK_VectorSplat: { 1036ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman const llvm::Type *DstTy = ConvertType(DestTy); 1037ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *Elt = Visit(const_cast<Expr*>(E)); 1038ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1039ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Insert the element in element zero of an undef vector 1040ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *UnV = llvm::UndefValue::get(DstTy); 1041ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *Idx = 1042ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 0); 1043ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 1044ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1045ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Splat the element across to all elements 1046ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::SmallVector<llvm::Constant*, 16> Args; 1047ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 1048ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman for (unsigned i = 0; i < NumElements; i++) 1049ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Args.push_back(llvm::ConstantInt::get( 1050ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Type::getInt32Ty(VMContext), 0)); 1051ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1052ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 1053ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 1054ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Yay; 1055ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 10568c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_IntegralCast: 10578c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_IntegralToFloating: 10588c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_FloatingToIntegral: 10598c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman case CastExpr::CK_FloatingCast: 1060d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return EmitScalarConversion(Visit(E), E->getType(), DestTy); 1061ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 10623a1737030e3c8d209987325c61dacb8e4a65123bEli Friedman case CastExpr::CK_MemberPointerToBoolean: 10633a1737030e3c8d209987325c61dacb8e4a65123bEli Friedman return CGF.EvaluateExprAsBool(E); 1064e9776247577715ad3a19461769a3488a445a8cbdAnders Carlsson } 1065db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 106658a2e944faa16f1f61439acd2e71b19f50189511Chris Lattner // Handle cases where the source is an non-complex type. 1067db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 106819a1d7c646729eb858b15583e647262a22de3637Chris Lattner if (!CGF.hasAggregateLLVMType(E->getType())) { 10693707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner Value *Src = Visit(const_cast<Expr*>(E)); 10703707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 10713707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Use EmitScalarConversion to perform the conversion. 10723707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return EmitScalarConversion(Src, E->getType(), DestTy); 10733707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 1074db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10759b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (E->getType()->isAnyComplexType()) { 107619a1d7c646729eb858b15583e647262a22de3637Chris Lattner // Handle cases where the source is a complex type. 10777f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreImag = true; 10787f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreImagAssign = true; 10797f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreReal = IgnoreResultAssign; 10807f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreRealAssign = IgnoreResultAssign; 10817f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (DestTy->isBooleanType()) 10827f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreImagAssign = IgnoreImag = false; 10837f79f9be5916c51c35da4f126b7c12596a101607Mike Stump else if (DestTy->isVoidType()) { 10847f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreReal = IgnoreImag = false; 10857f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreRealAssign = IgnoreImagAssign = true; 10867f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } 10877f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CodeGenFunction::ComplexPairTy V 10887f79f9be5916c51c35da4f126b7c12596a101607Mike Stump = CGF.EmitComplexExpr(E, IgnoreReal, IgnoreImag, IgnoreRealAssign, 10897f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreImagAssign); 10907f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitComplexToScalarConversion(V, E->getType(), DestTy); 109119a1d7c646729eb858b15583e647262a22de3637Chris Lattner } 109210b00cfe6422906b223724048b9b2123968d3baaChris Lattner 109319a1d7c646729eb858b15583e647262a22de3637Chris Lattner // Okay, this is a cast from an aggregate. It must be a cast to void. Just 109419a1d7c646729eb858b15583e647262a22de3637Chris Lattner // evaluate the result and return. 10957f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitAggExpr(E, 0, false, true); 109619a1d7c646729eb858b15583e647262a22de3637Chris Lattner return 0; 10977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 10987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 10993379320c10001d7e1ee5d7e7142c417f797cfe82Chris LattnerValue *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 110091d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner return CGF.EmitCompoundStmt(*E->getSubStmt(), 110191d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner !E->getType()->isVoidType()).getScalarVal(); 11023379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner} 11033379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 1104a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike StumpValue *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 1105f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian llvm::Value *V = CGF.GetAddrOfBlockDecl(E); 1106f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian if (E->getType().isObjCGCWeak()) 1107f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian return CGF.CGM.getObjCRuntime().EmitObjCWeakRead(CGF, V); 11082da84ff228a231adbd3f6f236b857f752d02959aDaniel Dunbar return Builder.CreateLoad(V, "tmp"); 11094e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump} 11103379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 11117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 11127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Unary Operators 11137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 11147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 11167f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 11177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 1118f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Op->getType()->isFPOrFPVectorTy()) 111987415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFNeg(Op, "neg"); 11207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNeg(Op, "neg"); 11217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 11227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 11247f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 11257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 11267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNot(Op, "neg"); 11277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 11287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 11307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Compare operand to zero. 11317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 1132db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 11337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Invert value. 11347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // TODO: Could dynamically modify easy computations here. For example, if 11357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // the operand is an icmp ne, turn into icmp eq. 11367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BoolVal = Builder.CreateNot(BoolVal, "lnot"); 1137db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 11389f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson // ZExt result to the expr type. 11399f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext"); 11407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 11417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11428ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas GregorValue *ScalarExprEmitter::VisitOffsetOfExpr(const OffsetOfExpr *E) { 11438ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor Expr::EvalResult Result; 11448ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor if(E->Evaluate(Result, CGF.getContext())) 11458ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 11468ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 11478ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor // FIXME: Cannot support code generation for non-constant offsetof. 11488ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor unsigned DiagID = CGF.CGM.getDiags().getCustomDiagID(Diagnostic::Error, 11498ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor "cannot compile non-constant __builtin_offsetof"); 11508ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor CGF.CGM.getDiags().Report(CGF.getContext().getFullLoc(E->getLocStart()), 11518ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor DiagID) 11528ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor << E->getSourceRange(); 11538ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 11548ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor return llvm::Constant::getNullValue(ConvertType(E->getType())); 11558ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor} 11568ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 11570518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// VisitSizeOfAlignOfExpr - Return the size or alignment of the type of 11580518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// argument of the sizeof expression as an integer. 11590518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlValue * 11600518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) { 11610518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl QualType TypeToSize = E->getTypeOfArgument(); 1162f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isSizeOf()) { 1163db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (const VariableArrayType *VAT = 1164f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.getContext().getAsVariableArrayType(TypeToSize)) { 1165f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isArgumentType()) { 1166f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // sizeof(type) - make sure to emit the VLA size. 1167f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.EmitVLASize(TypeToSize); 11688f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman } else { 11698f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // C99 6.5.3.4p2: If the argument is an expression of type 11708f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // VLA, it is evaluated. 11718f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman CGF.EmitAnyExpr(E->getArgumentExpr()); 1172f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman } 1173db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 117496f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson return CGF.GetVLASize(VAT); 1175b50525ba0e996bc072cdb76152fcfe0bc64bb72aAnders Carlsson } 11765d46315ca3cbbfe0d0f5f65520b618fb05dd4446Anders Carlsson } 1177f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman 1178db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If this isn't sizeof(vla), the result must be constant; use the constant 1179db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // folding logic so we don't have to duplicate it here. 1180f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman Expr::EvalResult Result; 1181f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman E->Evaluate(Result, CGF.getContext()); 11824a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 11837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 11847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 118546f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 118646f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 11879b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (Op->getType()->isAnyComplexType()) 11887f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return CGF.EmitComplexExpr(Op, false, true, false, true).first; 118946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return Visit(Op); 119046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 119146f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 119246f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 11939b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (Op->getType()->isAnyComplexType()) 11947f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return CGF.EmitComplexExpr(Op, true, false, true, false).second; 1195db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 11967f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __imag on a scalar returns zero. Emit the subexpr to ensure side 11977f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // effects are evaluated, but not the actual value. 11987f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (E->isLvalue(CGF.getContext()) == Expr::LV_Valid) 11997f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitLValue(Op); 12007f79f9be5916c51c35da4f126b7c12596a101607Mike Stump else 12017f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitScalarExpr(Op, true); 1202c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson return llvm::Constant::getNullValue(ConvertType(E->getType())); 120346f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 120446f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 12051eb4433ac451dc16f4133a88af2d002ac26c58efMike StumpValue *ScalarExprEmitter::VisitUnaryOffsetOf(const UnaryOperator *E) { 120635183aca180a2b9b2c637cd625a40a7e147d6a32Eli Friedman Value* ResultAsPtr = EmitLValue(E->getSubExpr()).getAddress(); 1207769e411b72465a63454cdd416ff26ff313d43505Eli Friedman const llvm::Type* ResultType = ConvertType(E->getType()); 120835183aca180a2b9b2c637cd625a40a7e147d6a32Eli Friedman return Builder.CreatePtrToInt(ResultAsPtr, ResultType, "offsetof"); 12095a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 121046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 12117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Binary Operators 12137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerBinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 12167f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 12177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BinOpInfo Result; 12187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.LHS = Visit(E->getLHS()); 12197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.RHS = Visit(E->getRHS()); 12201f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Result.Ty = E->getType(); 12217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.E = E; 12227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Result; 12237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12256a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue ScalarExprEmitter::EmitCompoundAssignLValue( 12266a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E, 12276a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), 12286a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *&BitFieldResult) { 122954d76db0aa7107597cac0b80d8e138a37e6d1de9Benjamin Kramer QualType LHSTy = E->getLHS()->getType(); 12306a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor BitFieldResult = 0; 12311f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo OpInfo; 12326a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1233ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman if (E->getComputationResultType()->isAnyComplexType()) { 1234db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // This needs to go through the complex expression emitter, but it's a tad 1235db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // complicated to do that... I'm leaving it out for now. (Note that we do 1236db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // actually need the imaginary part of the RHS for multiplication and 1237db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // division.) 1238ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman CGF.ErrorUnsupported(E, "complex compound assignment"); 12396a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor llvm::UndefValue::get(CGF.ConvertType(E->getType())); 12406a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LValue(); 12411f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 12426a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1243cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // Emit the RHS first. __block variables need to have the rhs evaluated 1244cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // first, plus this should improve codegen a little. 1245cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.RHS = Visit(E->getRHS()); 1246cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.Ty = E->getComputationResultType(); 1247cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.E = E; 1248ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // Load/convert the LHS. 1249b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHSLV = EmitCheckedLValue(E->getLHS()); 1250ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy); 1251ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 1252ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman E->getComputationLHSType()); 12536a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 12541f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Expand the binary operator. 12551f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *Result = (this->*Func)(OpInfo); 12566a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 12578c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Convert the result back to the LHS type. 1258ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 12596a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1260db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Store the result value into the LHS lvalue. Bit-fields are handled 1261db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // specially because the result is altered by the store, i.e., [C99 6.5.16p1] 1262db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // 'An assignment expression has the value of the left operand after the 1263db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // assignment...'. 1264f0fe5bc0e46038dc79cdd27fcf0c77ad4789fdffDaniel Dunbar if (LHSLV.isBitField()) { 12657f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (!LHSLV.isVolatileQualified()) { 12667f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy, 12677f79f9be5916c51c35da4f126b7c12596a101607Mike Stump &Result); 12686a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor BitFieldResult = Result; 12696a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LHSLV; 12707f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } else 12717f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy); 12727f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } else 1273ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy); 12746a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LHSLV; 12756a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 12766a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 12776a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorValue *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 12786a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 12796a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor bool Ignore = TestAndClearIgnoreResultAssign(); 12806a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *BitFieldResult; 12816a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor LValue LHSLV = EmitCompoundAssignLValue(E, Func, BitFieldResult); 12826a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor if (BitFieldResult) 12836a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return BitFieldResult; 12846a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 12857f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 12867f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 12877f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitLoadOfLValue(LHSLV, E->getType()); 12881f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner} 12891f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 12901f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 12917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 1292f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 12937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 12941f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner else if (Ops.Ty->isUnsignedIntegerType()) 12957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 12967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 12977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 12987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 13017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Rem in C can't be a floating point type: C99 6.5.5p2. 13021f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner if (Ops.Ty->isUnsignedIntegerType()) 13037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 13047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 13057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 13067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13082add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike StumpValue *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 13092add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned IID; 13102add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned OpID = 0; 13115d8b2cf9fd704f6ca5e33525803a65421c0b440eMike Stump 1312035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump switch (Ops.E->getOpcode()) { 1313035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Add: 1314035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::AddAssign: 1315035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 1; 1316035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::sadd_with_overflow; 1317035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1318035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Sub: 1319035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::SubAssign: 1320035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 2; 1321035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::ssub_with_overflow; 1322035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1323035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Mul: 1324035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::MulAssign: 1325035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 3; 1326035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::smul_with_overflow; 1327035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1328035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump default: 1329035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump assert(false && "Unsupported operation for overflow detection"); 1330ab4eff620a9ce0ea62cdf29529a66c2c98d116f5Daniel Dunbar IID = 0; 1331035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump } 1332035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID <<= 1; 1333035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID |= 1; 1334035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump 13352add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 13362add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 13372add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1); 13382add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 13392add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 13402add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 13412add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 13422add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 13432add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Branch in case of overflow. 13442add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::BasicBlock *initialBB = Builder.GetInsertBlock(); 13452add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::BasicBlock *overflowBB = 13462add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump CGF.createBasicBlock("overflow", CGF.CurFn); 13472add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::BasicBlock *continueBB = 13482add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump CGF.createBasicBlock("overflow.continue", CGF.CurFn); 13492add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 13502add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateCondBr(overflow, overflowBB, continueBB); 13512add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 13522add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Handle overflow 13532add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 13542add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(overflowBB); 13552add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 13562add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Handler is: 1357db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // long long *__overflow_handler)(long long a, long long b, char op, 13582add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // char width) 13592add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump std::vector<const llvm::Type*> handerArgTypes; 13600032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson handerArgTypes.push_back(llvm::Type::getInt64Ty(VMContext)); 13610032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson handerArgTypes.push_back(llvm::Type::getInt64Ty(VMContext)); 13620032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson handerArgTypes.push_back(llvm::Type::getInt8Ty(VMContext)); 13630032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson handerArgTypes.push_back(llvm::Type::getInt8Ty(VMContext)); 13640032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::FunctionType *handlerTy = llvm::FunctionType::get( 13650032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::Type::getInt64Ty(VMContext), handerArgTypes, false); 13662add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Value *handlerFunction = 13672add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump CGF.CGM.getModule().getOrInsertGlobal("__overflow_handler", 136896e0fc726c6fe7538522c60743705d5e696b40afOwen Anderson llvm::PointerType::getUnqual(handlerTy)); 13692add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump handlerFunction = Builder.CreateLoad(handlerFunction); 13702add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 13712add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Value *handlerResult = Builder.CreateCall4(handlerFunction, 13720032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson Builder.CreateSExt(Ops.LHS, llvm::Type::getInt64Ty(VMContext)), 13730032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson Builder.CreateSExt(Ops.RHS, llvm::Type::getInt64Ty(VMContext)), 13740032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), OpID), 1375db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::ConstantInt::get(llvm::Type::getInt8Ty(VMContext), 13762add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump cast<llvm::IntegerType>(opTy)->getBitWidth())); 13772add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 13782add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump handlerResult = Builder.CreateTrunc(handlerResult, opTy); 13792add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 13802add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateBr(continueBB); 1381db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 13822add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Set up the continuation 13832add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(continueBB); 13842add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Get the correct result 13852add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::PHINode *phi = Builder.CreatePHI(opTy); 13862add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump phi->reserveOperandSpace(2); 13872add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump phi->addIncoming(result, initialBB); 13882add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump phi->addIncoming(handlerResult, overflowBB); 13892add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 13902add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump return phi; 13912add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump} 13927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { 139458f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (!Ops.Ty->isAnyPointerType()) { 139587415d2d45224596a96ef02310701797d56b2c19Chris Lattner if (CGF.getContext().getLangOptions().OverflowChecking && 139687415d2d45224596a96ef02310701797d56b2c19Chris Lattner Ops.Ty->isSignedIntegerType()) 13972add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump return EmitOverflowCheckedBinOp(Ops); 1398db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1399f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 140087415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFAdd(Ops.LHS, Ops.RHS, "add"); 1401bf933a0cb628670490c15367b3f5ccb3193354a7Dan Gohman 1402bf933a0cb628670490c15367b3f5ccb3193354a7Dan Gohman // Signed integer overflow is undefined behavior. 1403bf933a0cb628670490c15367b3f5ccb3193354a7Dan Gohman if (Ops.Ty->isSignedIntegerType()) 1404bf933a0cb628670490c15367b3f5ccb3193354a7Dan Gohman return Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "add"); 1405bf933a0cb628670490c15367b3f5ccb3193354a7Dan Gohman 14067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 14072add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 1408daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 140914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (Ops.Ty->isPointerType() && 14106217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek Ops.Ty->getAs<PointerType>()->isVariableArrayType()) { 1411daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size 1412daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman CGF.ErrorUnsupported(Ops.E, "VLA pointer addition"); 1413daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 14148f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Value *Ptr, *Idx; 14158f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Expr *IdxExp; 14166217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek const PointerType *PT = Ops.E->getLHS()->getType()->getAs<PointerType>(); 1417db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump const ObjCObjectPointerType *OPT = 1418183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall Ops.E->getLHS()->getType()->getAs<ObjCObjectPointerType>(); 141914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (PT || OPT) { 14208f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.LHS; 14218f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.RHS; 14228f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner IdxExp = Ops.E->getRHS(); 142314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } else { // int + pointer 14246217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek PT = Ops.E->getRHS()->getType()->getAs<PointerType>(); 1425183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall OPT = Ops.E->getRHS()->getType()->getAs<ObjCObjectPointerType>(); 142614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff assert((PT || OPT) && "Invalid add expr"); 14278f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.RHS; 14288f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.LHS; 14298f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner IdxExp = Ops.E->getLHS(); 14308f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 14318f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner 14328f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 14337cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 14348f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // Zero or sign extend the pointer value based on whether the index is 14358f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // signed or not. 14360032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson const llvm::Type *IdxType = 14370032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::IntegerType::get(VMContext, CGF.LLVMPointerWidth); 14389619662a1d42e2008b865d3459c0677e149dad1bChris Lattner if (IdxExp->getType()->isSignedIntegerType()) 14398f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 14408f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner else 14418f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 14428f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 144314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType ElementType = PT ? PT->getPointeeType() : OPT->getPointeeType(); 1444db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1445c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = ElementType->getAs<ObjCObjectType>()) { 1446db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 14474a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1448199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext().getTypeSizeInChars(OIT).getQuantity()); 14492a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 14503c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 14512a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 14522a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 14532a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1454db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 14552a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1456db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Explicitly handle GNU void* and function pointer arithmetic extensions. The 1457db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // GNU void* casts amount to no-ops since our void* type is i8*, but this is 1458db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // future proof. 1459b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (ElementType->isVoidType() || ElementType->isFunctionType()) { 14603c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1461b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 14622a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 1463b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1464db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1465db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1466664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ptr, Idx, "add.ptr"); 14677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { 14702add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump if (!isa<llvm::PointerType>(Ops.LHS->getType())) { 1471035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump if (CGF.getContext().getLangOptions().OverflowChecking 1472035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump && Ops.Ty->isSignedIntegerType()) 14732add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump return EmitOverflowCheckedBinOp(Ops); 147487415d2d45224596a96ef02310701797d56b2c19Chris Lattner 1475f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 147687415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFSub(Ops.LHS, Ops.RHS, "sub"); 14772eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner 14782eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner // Signed integer overflow is undefined behavior. 14792eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner if (Ops.Ty->isSignedIntegerType()) 14802eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub"); 14812eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner 14827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 14832add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 14841f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 148514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (Ops.E->getLHS()->getType()->isPointerType() && 14866217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek Ops.E->getLHS()->getType()->getAs<PointerType>()->isVariableArrayType()) { 1487daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size for 1488daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-int 1489daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the division needs to account for the VLA size for 1490daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-ptr. 1491daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman CGF.ErrorUnsupported(Ops.E, "VLA pointer subtraction"); 1492daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 1493daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 1494b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar const QualType LHSType = Ops.E->getLHS()->getType(); 149514108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType LHSElementType = LHSType->getPointeeType(); 14968c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar if (!isa<llvm::PointerType>(Ops.RHS->getType())) { 14978c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - int 14988c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *Idx = Ops.RHS; 14998c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 15007cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 15018c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Zero or sign extend the pointer value based on whether the index is 15028c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // signed or not. 15030032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson const llvm::Type *IdxType = 15040032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::IntegerType::get(VMContext, CGF.LLVMPointerWidth); 15058c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar if (Ops.E->getRHS()->getType()->isSignedIntegerType()) 15068c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 15078c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar else 15088c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 15098c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 15108c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateNeg(Idx, "sub.ptr.neg"); 1511b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar 1512db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1513c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = LHSElementType->getAs<ObjCObjectType>()) { 1514db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 15154a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1516199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext(). 1517199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getTypeSizeInChars(OIT).getQuantity()); 15182a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 15193c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 15202a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 15212a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr"); 15222a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1523db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 15242a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1525b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // Explicitly handle GNU void* and function pointer arithmetic 1526db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // extensions. The GNU void* casts amount to no-ops since our void* type is 1527db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // i8*, but this is future proof. 1528b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 15293c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1530b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1531b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr"); 1532b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1533db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1534db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1535664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ops.LHS, Idx, "sub.ptr"); 1536820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar } else { 15378c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - pointer 15388c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *LHS = Ops.LHS; 15398c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *RHS = Ops.RHS; 1540db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1541199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ElementSize; 1542820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar 1543e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Handle GCC extension for pointer arithmetic on void* and function pointer 1544e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // types. 1545e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 1546199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CharUnits::One(); 15478c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } else { 1548199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CGF.getContext().getTypeSizeInChars(LHSElementType); 15498c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 1550db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 15518c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar const llvm::Type *ResultType = ConvertType(Ops.Ty); 15528c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); 15538c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 15548c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 1555db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1556e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Optimize out the shift for element size of 1. 1557199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck if (ElementSize.isOne()) 1558e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner return BytesBetween; 1559df1109434abd465a4db2e6f69ec2688866660367Dan Gohman 1560df1109434abd465a4db2e6f69ec2688866660367Dan Gohman // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 1561db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // pointer difference in C is only defined in the case where both operands 1562db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // are pointing to elements of an array. 1563199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck Value *BytesPerElt = 1564199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck llvm::ConstantInt::get(ResultType, ElementSize.getQuantity()); 1565df1109434abd465a4db2e6f69ec2688866660367Dan Gohman return Builder.CreateExactSDiv(BytesBetween, BytesPerElt, "sub.ptr.div"); 15667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 15677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 15687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 15707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 15717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 15727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 15737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 15747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1575db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1576be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 1577be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1578be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1579be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1580be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1581be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 158215037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 1583be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 1584be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 1585be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 15867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateShl(Ops.LHS, RHS, "shl"); 15877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 15887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 15907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 15917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 15927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 15937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 15947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1595db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1596be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 1597be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1598be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1599be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1600be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1601be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 160215037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 1603be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 1604be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 1605be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 16061f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner if (Ops.Ty->isUnsignedIntegerType()) 16077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 16087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 16097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 16107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 16127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc) { 16137f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 16144f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *Result; 16157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner QualType LHSTy = E->getLHS()->getType(); 1616b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman if (LHSTy->isMemberFunctionPointerType()) { 1617b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *LHSPtr = CGF.EmitAnyExprToTemp(E->getLHS()).getAggregateAddr(); 1618b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *RHSPtr = CGF.EmitAnyExprToTemp(E->getRHS()).getAggregateAddr(); 1619b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *LHSFunc = Builder.CreateStructGEP(LHSPtr, 0); 1620b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSFunc = Builder.CreateLoad(LHSFunc); 1621b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *RHSFunc = Builder.CreateStructGEP(RHSPtr, 0); 1622b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman RHSFunc = Builder.CreateLoad(RHSFunc); 1623b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *ResultF = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1624b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSFunc, RHSFunc, "cmp.func"); 1625b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *NullPtr = llvm::Constant::getNullValue(LHSFunc->getType()); 1626b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *ResultNull = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1627b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSFunc, NullPtr, "cmp.null"); 1628b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *LHSAdj = Builder.CreateStructGEP(LHSPtr, 1); 1629b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSAdj = Builder.CreateLoad(LHSAdj); 1630b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman llvm::Value *RHSAdj = Builder.CreateStructGEP(RHSPtr, 1); 1631b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman RHSAdj = Builder.CreateLoad(RHSAdj); 1632b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Value *ResultA = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 1633b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman LHSAdj, RHSAdj, "cmp.adj"); 1634b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman if (E->getOpcode() == BinaryOperator::EQ) { 1635b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateOr(ResultNull, ResultA, "or.na"); 1636b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateAnd(Result, ResultF, "and.f"); 1637b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else { 1638b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman assert(E->getOpcode() == BinaryOperator::NE && 1639b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman "Member pointer comparison other than == or != ?"); 1640b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateAnd(ResultNull, ResultA, "and.na"); 1641b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman Result = Builder.CreateOr(Result, ResultF, "or.f"); 1642b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } 1643b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else if (!LHSTy->isAnyComplexType()) { 16447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS = Visit(E->getLHS()); 16457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 1646db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1647f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (LHS->getType()->isFPOrFPVectorTy()) { 16487a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 16497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 1650ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman } else if (LHSTy->isSignedIntegerType()) { 1651ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 16527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 16537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 1654ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman // Unsigned integers and pointers. 1655ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 16567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 16577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 16589c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner 16599c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // If this is a vector comparison, sign extend the result to the appropriate 16609c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // vector integer type and return it (don't convert to bool). 16619c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner if (LHSTy->isVectorType()) 16629c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 1663db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 16647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 16657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex Comparison: can only be an equality comparison. 16667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 16677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 1668db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1669183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType CETy = LHSTy->getAs<ComplexType>()->getElementType(); 1670db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 16714f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *ResultR, *ResultI; 16727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (CETy->isRealFloatingType()) { 16737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 16747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 16757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 16767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 16777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 16787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex comparisons can only be equality comparisons. As such, signed 16797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // and unsigned opcodes are the same. 16807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 16817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 16827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 16837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 16847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1685db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 16867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getOpcode() == BinaryOperator::EQ) { 16877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 16887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 16897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E->getOpcode() == BinaryOperator::NE && 16907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Complex comparison other than == or != ?"); 16917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 16927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 16937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 169432f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes 169532f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 16967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 16977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 16997f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool Ignore = TestAndClearIgnoreResultAssign(); 17007f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 17017f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __block variables need to have the rhs evaluated first, plus this should 17027f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // improve codegen just a little. 17037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 1704b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHS = EmitCheckedLValue(E->getLHS()); 1705db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1706ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar // Store the value into the LHS. Bit-fields are handled specially 1707371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // because the result is altered by the store, i.e., [C99 6.5.16p1] 1708371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // 'An assignment expression has the value of the left operand after 1709daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // the assignment...'. 1710f0fe5bc0e46038dc79cdd27fcf0c77ad4789fdffDaniel Dunbar if (LHS.isBitField()) { 17117f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (!LHS.isVolatileQualified()) { 17127f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType(), 17137f79f9be5916c51c35da4f126b7c12596a101607Mike Stump &RHS); 17147f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return RHS; 17157f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } else 17167f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType()); 17177f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } else 1718ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType()); 17197f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 17207f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 17217f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitLoadOfLValue(LHS, E->getType()); 17227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 17257804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 17267804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 172720eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 172820eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 && X, just emit X without inserting the control flow. 172920eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 173020eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == 1) { // If we have 1 && X, just emit X. 17310946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 17327804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 17337804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 17340946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1735db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 17367804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 173720eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 17387804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::Constant::getNullValue(ResTy); 17390946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1740db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 17419615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 17429615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 174320eb09d562b80420a3328be789547af354bf3e36Chris Lattner 1744f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is false, go to the failure (cont) block. 1745f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 1746f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1747f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 1748f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be false. Start 1749f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 17500032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 17510032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 1752f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 1753f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 1754f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 17553b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 1756db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 175772119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 17587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 17597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 176072119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 1761db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 17627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 17637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 1764f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1765f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 1766f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 17677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 17687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 1769db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 17707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 17717804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 17727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 17757804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 17767804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 177720eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 177820eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 || X, just emit X without inserting the control flow. 177920eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 178020eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == -1) { // If we have 0 || X, just emit X. 17810946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 17827804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 17837804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 17840946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1785db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 17867804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 178720eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 17887804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::ConstantInt::get(ResTy, 1); 17890946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 1790db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 17919615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 17929615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 1793db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1794f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is true, go to the success (cont) block. 1795f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 1796f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1797f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 1798f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be true. Start 1799f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 18000032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 18010032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 1802f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 1803f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 1804f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 18053b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 1806f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 180772119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 180833da07db112f4877f6ab13e20db08b9bb86a0c2eAnders Carlsson 1809f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit the RHS condition as a bool value. 18107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 18117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 1812db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 181372119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 1814db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 18167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 1817db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1818f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 1819f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 1820f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBlock(ContBlock); 18217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 1822db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 18247804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 18257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 18267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 18277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 18287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitStmt(E->getLHS()); 1829a448fb2da03ece39978784793eea68760e8205a1Daniel Dunbar CGF.EnsureInsertPoint(); 18307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getRHS()); 18317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 18327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 18337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 18347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Other Operators 18357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 18367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 18379802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 18389802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// expression is cheap enough and side-effect-free enough to evaluate 18399802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// unconditionally instead of conditionally. This is used to convert control 18409802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// flow into selects in some cases. 1841df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stumpstatic bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 1842df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CodeGenFunction &CGF) { 18439802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) 1844df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr(), CGF); 1845db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18469802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // TODO: Allow anything we can constant fold to an integer or fp constant. 18479802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) || 18489802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner isa<FloatingLiteral>(E)) 18499802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 1850db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18519802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // Non-volatile automatic variables too, to get "cond ? X : Y" where 18529802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // X and Y are local variables. 18539802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 18549802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 1855df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (VD->hasLocalStorage() && !(CGF.getContext() 1856df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .getCanonicalType(VD->getType()) 1857df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .isVolatileQualified())) 18589802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 1859db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18609802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return false; 18619802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner} 18629802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 18639802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 18647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter:: 18657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerVisitConditionalOperator(const ConditionalOperator *E) { 18667f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 186731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the condition constant folds and can be elided, try to avoid emitting 186831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the condition and the dead arm. 186931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getCond())){ 1870c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner Expr *Live = E->getLHS(), *Dead = E->getRHS(); 187131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (Cond == -1) 1872c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner std::swap(Live, Dead); 1873db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 187431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the dead side doesn't have labels we need, and if the Live side isn't 187531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the gnu missing ?: extension (which we could handle, but don't bother 187631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // to), just emit the Live part. 187731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if ((!Dead || !CGF.ContainsLabel(Dead)) && // No labels in dead part 187831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Live) // Live part isn't missing. 187931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return Visit(Live); 1880c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner } 1881db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1882db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18839802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // If this is a really simple expression (like x ? 4 : 5), emit this as a 18849802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // select instead of as control flow. We can only do this if it is cheap and 1885531a550531c144a58438f187816abbf1879e1c4eChris Lattner // safe to evaluate the LHS and RHS unconditionally. 1886df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (E->getLHS() && isCheapEnoughToEvaluateUnconditionally(E->getLHS(), 1887df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CGF) && 1888df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump isCheapEnoughToEvaluateUnconditionally(E->getRHS(), CGF)) { 18899802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *CondV = CGF.EvaluateExprAsBool(E->getCond()); 18909802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *LHS = Visit(E->getLHS()); 18919802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *RHS = Visit(E->getRHS()); 18929802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 18939802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner } 1894db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1895db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1896be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 1897be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 18989615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 1899035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Value *CondVal = 0; 1900035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner 1901db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If we don't have the GNU missing condition extension, emit a branch on bool 1902db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // the normal way. 190312d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner if (E->getLHS()) { 190412d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for 190512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the branch on bool. 190612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 190712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner } else { 190812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, for the ?: extension, evaluate the conditional and then 190912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // convert it to bool the hard way. We do this explicitly because we need 191012d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the unconverted value for the missing middle value of the ?:. 1911035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CondVal = CGF.EmitScalarExpr(E->getCond()); 1912db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 191312d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // In some cases, EmitScalarConversion will delete the "CondVal" expression 191412d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // if there are no extra uses (an optimization). Inhibit this by making an 191512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // extra dead use, because we're going to add a use of CondVal later. We 191612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // don't use the builder for this, because we don't want it to get optimized 191712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // away. This leaves dead code, but the ?: extension isn't common. 191812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner new llvm::BitCastInst(CondVal, CondVal->getType(), "dummy?:holder", 191912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner Builder.GetInsertBlock()); 1920db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1921035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Value *CondBoolVal = 1922035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.EmitScalarConversion(CondVal, E->getCond()->getType(), 1923035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.getContext().BoolTy); 1924035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock); 1925035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner } 1926fb6fa30a9b06670deb14f862dddbc49a12552939Anders Carlsson 192772119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 19287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(LHSBlock); 1929db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the GNU extension for missing LHS. 1931a21ddb30e56026967d58e26c5212744e1831305bChris Lattner Value *LHS; 1932a21ddb30e56026967d58e26c5212744e1831305bChris Lattner if (E->getLHS()) 1933856226c37ff10955c7f3f07ce6fa9522da23a3a5Eli Friedman LHS = Visit(E->getLHS()); 1934a21ddb30e56026967d58e26c5212744e1831305bChris Lattner else // Perform promotions, to handle cases like "short ?: int" 1935a21ddb30e56026967d58e26c5212744e1831305bChris Lattner LHS = EmitScalarConversion(CondVal, E->getCond()->getType(), E->getType()); 1936db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 193772119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 19387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHSBlock = Builder.GetInsertBlock(); 1939d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 1940db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 194172119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 19427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 1943db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1944856226c37ff10955c7f3f07ce6fa9522da23a3a5Eli Friedman Value *RHS = Visit(E->getRHS()); 194572119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 19467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 1947d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 1948db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 1950db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 195148daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman // If the LHS or RHS is a throw expression, it will be legitimately null. 195248daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!LHS) 195348daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return RHS; 195448daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!RHS) 195548daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return LHS; 1956db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Create a PHI node for the real part. 19587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond"); 19597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->reserveOperandSpace(2); 19607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(LHS, LHSBlock); 19617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHS, RHSBlock); 19627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return PN; 19637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 19667976932a1c256d447316ffac58e9821417725e34Eli Friedman return Visit(E->getChosenSubExpr(CGF.getContext())); 19677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19692202bce80fc72d067cbe67dc1512f7b45351fd31Chris LattnerValue *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 19704fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 1971ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 1972ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 1973ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson // If EmitVAArg fails, we fall back to the LLVM instruction. 1974db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (!ArgPtr) 1975ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 1976ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 19777f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // FIXME Volatility. 1978ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateLoad(ArgPtr); 19797c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson} 19807c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 1981df6b68c9487aed2042c7fc23db10a79f89083a11Mike StumpValue *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *BE) { 19820892099dbc640720400a1d9decd2733a09d733e5Mike Stump return CGF.BuildBlockLiteralTmp(BE); 1983df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump} 1984df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 19857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 19867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Entry Point into this File 19877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 19887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1989db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitScalarExpr - Emit the computation of the specified expression of scalar 1990db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type, ignoring the result. 19917f79f9be5916c51c35da4f126b7c12596a101607Mike StumpValue *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 19927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E && !hasAggregateLLVMType(E->getType()) && 19937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Invalid scalar expression to emit"); 1994db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19957f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return ScalarExprEmitter(*this, IgnoreResultAssign) 19967f79f9be5916c51c35da4f126b7c12596a101607Mike Stump .Visit(const_cast<Expr*>(E)); 19977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19983707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 19993707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 20003707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 20014f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 20024f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 20033707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 20043707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner "Invalid scalar expression to emit"); 20053707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 20063707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 20074f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 2008db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 2009db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 2010db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 20114f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 20124f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, 20134f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 20149b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 20154f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner "Invalid complex -> scalar conversion"); 20164f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 20174f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner DstTy); 20184f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 2019cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 2020820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz JahanianLValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 2021820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian llvm::Value *V; 2022820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // object->isa or (*object).isa 2023820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // Generate code as for: *(Class*)object 20245ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian // build Class* type 20255ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian const llvm::Type *ClassPtrTy = ConvertType(E->getType()); 20265ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian 2027820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Expr *BaseExpr = E->getBase(); 20285ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian if (BaseExpr->isLvalue(getContext()) != Expr::LV_Valid) { 20295ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = CreateTempAlloca(ClassPtrTy, "resval"); 20305ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian llvm::Value *Src = EmitScalarExpr(BaseExpr); 20315ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian Builder.CreateStore(Src, V); 20329f9efe6d58f49bce01b548bf81245f053b632a02Fariborz Jahanian LValue LV = LValue::MakeAddr(V, MakeQualifiers(E->getType())); 20339f9efe6d58f49bce01b548bf81245f053b632a02Fariborz Jahanian V = ScalarExprEmitter(*this).EmitLoadOfLValue(LV, E->getType()); 20345ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 20355ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian else { 20365ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian if (E->isArrow()) 20375ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr); 20385ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian else 20395ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = EmitLValue(BaseExpr).getAddress(); 20405ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 2041820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 2042820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // build Class* type 2043820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian ClassPtrTy = ClassPtrTy->getPointerTo(); 2044820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian V = Builder.CreateBitCast(V, ClassPtrTy); 2045820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian LValue LV = LValue::MakeAddr(V, MakeQualifiers(E->getType())); 2046820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian return LV; 2047820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian} 2048820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 20496a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 20506a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue CodeGenFunction::EmitCompoundAssignOperatorLValue( 20516a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E) { 20526a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor ScalarExprEmitter Scalar(*this); 20536a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *BitFieldResult = 0; 20546a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor switch (E->getOpcode()) { 20556a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#define COMPOUND_OP(Op) \ 20566a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Op##Assign: \ 20576a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 20586a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor BitFieldResult) 20596a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Mul); 20606a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Div); 20616a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Rem); 20626a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Add); 20636a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Sub); 20646a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shl); 20656a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shr); 20666a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(And); 20676a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Xor); 20686a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Or); 20696a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#undef COMPOUND_OP 20706a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 20716a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::PtrMemD: 20726a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::PtrMemI: 20736a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Mul: 20746a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Div: 20756a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Rem: 20766a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Add: 20776a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Sub: 20786a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Shl: 20796a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Shr: 20806a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LT: 20816a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::GT: 20826a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LE: 20836a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::GE: 20846a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::EQ: 20856a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::NE: 20866a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::And: 20876a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Xor: 20886a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Or: 20896a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LAnd: 20906a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::LOr: 20916a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Assign: 20926a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor case BinaryOperator::Comma: 20936a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor assert(false && "Not valid compound assignment operators"); 20946a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor break; 20956a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor } 20966a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 20976a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor llvm_unreachable("Unhandled compound assignment operator"); 20986a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 2099