CGExprScalar.cpp revision 49c8465f14fc3b2e1a32c7016ad3fb4e2cf8d466
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 1478ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel#include "clang/Frontend/CodeGenOptions.h" 157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "CodeGenFunction.h" 164c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall#include "CGCXXABI.h" 17f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian#include "CGObjCRuntime.h" 187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "CodeGenModule.h" 1978ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel#include "CGDebugInfo.h" 20de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 2198c5ead87d720d8b68b6f236c3c3579a388fc882Daniel Dunbar#include "clang/AST/DeclObjC.h" 2219cc4abea06a9b49e0e16a50d335c064cd723572Anders Carlsson#include "clang/AST/RecordLayout.h" 23de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/StmtVisitor.h" 2425ddea7f7835c4b1804e458a5c866cde0097430aChris Lattner#include "clang/Basic/TargetInfo.h" 257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "llvm/Constants.h" 267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "llvm/Function.h" 2785f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson#include "llvm/GlobalVariable.h" 287c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson#include "llvm/Intrinsics.h" 292add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump#include "llvm/Module.h" 30f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner#include "llvm/Support/CFG.h" 314e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump#include "llvm/Target/TargetData.h" 32c89bf69c9289d2b2305f2c267daacc7312391898Chris Lattner#include <cstdarg> 336aad91a43e26118c824d976661077819265d9bc0Ted Kremenek 347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing namespace clang; 357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing namespace CodeGen; 367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing llvm::Value; 377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Scalar Expression Emitter 407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerstruct BinOpInfo { 437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS; 447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS; 451f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner QualType Ty; // Computation Type. 469a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinaryOperator::Opcode Opcode; // Opcode of BinOp to perform 479a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const Expr *E; // Entire expr, for error unsupported. May not be binop. 487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnernamespace { 5185b4521e34dcd4a0a4a1f0819e1123128e5a3125Benjamin Kramerclass ScalarExprEmitter 527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner : public StmtVisitor<ScalarExprEmitter, Value*> { 537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction &CGF; 5445d196b8387dcefc4df26cda114fa34c6528e928Daniel Dunbar CGBuilderTy &Builder; 557f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreResultAssign; 56a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson llvm::LLVMContext &VMContext; 577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerpublic: 587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 597f79f9be5916c51c35da4f126b7c12596a101607Mike Stump ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false) 60db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira), 61a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson VMContext(cgf.getLLVMContext()) { 627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 63db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Utilities 667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 687f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool TestAndClearIgnoreResultAssign() { 699c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner bool I = IgnoreResultAssign; 709c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner IgnoreResultAssign = false; 719c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return I; 729c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner } 737f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); } 757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); } 76b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue EmitCheckedLValue(const Expr *E) { return CGF.EmitCheckedLValue(E); } 777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(LValue LV, QualType T) { 799b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitLoadOfLValue(LV, T).getScalarVal(); 807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 81db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// EmitLoadOfLValue - Given an expression with complex type that represents a 837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// value l-value, this method emits the address of the l-value, then loads 847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// and returns the result. 857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(const Expr *E) { 86b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump return EmitLoadOfLValue(EmitCheckedLValue(E), E->getType()); 877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 88db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 899abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner /// EmitConversionToBool - Convert the specified expression value to a 903420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner /// boolean (i1) truth value. This is equivalent to "Val != 0". 919abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner Value *EmitConversionToBool(Value *Src, QualType DstTy); 92db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 933707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// EmitScalarConversion - Emit a conversion from the specified type to the 943707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// specified destination type, both of which are LLVM scalar types. 954f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy); 964f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 974f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner /// EmitComplexToScalarConversion - Emit a conversion from the specified 98db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump /// complex type to the specified destination type, where the destination type 99db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump /// is an LLVM scalar type. 1004f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 1014f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy); 102df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 103a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson /// EmitNullValue - Emit a value that corresponds to null for the given type. 104a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson Value *EmitNullValue(QualType Ty); 105a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 1067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 1077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Visitor Methods 1087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 1097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 110af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *Visit(Expr *E) { 111af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian llvm::DenseMap<const Expr *, llvm::Value *>::iterator I = 112af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian CGF.ConditionalSaveExprs.find(E); 113af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian if (I != CGF.ConditionalSaveExprs.end()) 114af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian return I->second; 115af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian 116af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian return StmtVisitor<ScalarExprEmitter, Value*>::Visit(E); 117af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian } 118af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian 1197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitStmt(Stmt *S) { 1207a9d49fd2bfac00e905b361ba76d26ab5b6c3b09Ted Kremenek S->dump(CGF.getContext().getSourceManager()); 1217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(0 && "Stmt can't have complex result type!"); 1227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 1237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitExpr(Expr *S); 125f51dc64f90851f636302dbaaf3f52c0524cdac36Fariborz Jahanian 126af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *VisitParenExpr(ParenExpr *PE) { 127af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian return Visit(PE->getSubExpr()); 128af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian } 1297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Leaves. 1317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitIntegerLiteral(const IntegerLiteral *E) { 1324a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(VMContext, E->getValue()); 1337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitFloatingLiteral(const FloatingLiteral *E) { 135bc0a2226c7fcd18b29b6846049e2cfcb872d3593Owen Anderson return llvm::ConstantFP::get(VMContext, E->getValue()); 1367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCharacterLiteral(const CharacterLiteral *E) { 1384a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 139e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman } 140e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 1414a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 1427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 143ed8abf18329df67b0abcbb3a10458bd8c1d2a595Douglas Gregor Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) { 144a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1457267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis } 1463f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson Value *VisitGNUNullExpr(const GNUNullExpr *E) { 147a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1483f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson } 1497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) { 1504a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), 151ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff CGF.getContext().typesAreCompatible( 152ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff E->getArgType1(), E->getArgType2())); 1537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1540027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Value *VisitOffsetOfExpr(OffsetOfExpr *E); 1550518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl Value *VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E); 1560ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar Value *VisitAddrLabelExpr(const AddrLabelExpr *E) { 157d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel()); 158d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return Builder.CreateBitCast(V, ConvertType(E->getType())); 1590ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar } 160db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // l-values. 1627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitDeclRefExpr(DeclRefExpr *E) { 16328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 16428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 16528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman assert(!Result.HasSideEffects && "Constant declref with side-effect?!"); 16625c2c8fb9309050612009a6571e2660e75531348Devang Patel llvm::ConstantInt *CI 16725c2c8fb9309050612009a6571e2660e75531348Devang Patel = llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 16825c2c8fb9309050612009a6571e2660e75531348Devang Patel CGF.EmitDeclRefExprDbgValue(E, CI); 16925c2c8fb9309050612009a6571e2660e75531348Devang Patel return CI; 17028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 1717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 1727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 173db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 174db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCSelectorExpr(E); 1759c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 176db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 177db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCProtocolExpr(E); 1789c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 179db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 1809c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return EmitLoadOfLValue(E); 1819c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 1820a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 18385c59edda02df48fae8dc85049743319bc6e7e89Daniel Dunbar return EmitLoadOfLValue(E); 1849c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 18509105f52b1f28cbb1374c27c3c70f5517e2c465dFariborz Jahanian Value *VisitObjCImplicitSetterGetterRefExpr( 18609105f52b1f28cbb1374c27c3c70f5517e2c465dFariborz Jahanian ObjCImplicitSetterGetterRefExpr *E) { 18743f447098d5e6162fbfb97ed38365284207a7fbeFariborz Jahanian return EmitLoadOfLValue(E); 18843f447098d5e6162fbfb97ed38365284207a7fbeFariborz Jahanian } 1899c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar Value *VisitObjCMessageExpr(ObjCMessageExpr *E) { 1909c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return CGF.EmitObjCMessageExpr(E).getScalarVal(); 1910a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar } 1920a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar 19383dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian Value *VisitObjCIsaExpr(ObjCIsaExpr *E) { 194820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian LValue LV = CGF.EmitObjCIsaExpr(E); 195820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Value *V = CGF.EmitLoadOfLValue(LV, E->getType()).getScalarVal(); 19683dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian return V; 19783dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian } 19883dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian 1997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 200d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E); 20128665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Value *VisitMemberExpr(MemberExpr *E); 202213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); } 203be20bb558cae5352898e6a913e29d24d20134841Chris Lattner Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 204be20bb558cae5352898e6a913e29d24d20134841Chris Lattner return EmitLoadOfLValue(E); 205be20bb558cae5352898e6a913e29d24d20134841Chris Lattner } 20635634f5ed67966c9f1fde38420e79cc6515cd673Devang Patel 2070533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *VisitInitListExpr(InitListExpr *E); 208db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2093498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) { 2103cb18bcefe39756f3b079fa1a62b4c9cbf6a592fAnders Carlsson return CGF.CGM.EmitNullConstant(E->getType()); 2113498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor } 212d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *VisitCastExpr(CastExpr *E) { 213c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman // Make sure to evaluate VLA bounds now so that we have them for later. 214745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (E->getType()->isVariablyModifiedType()) 215745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian CGF.EmitVLASize(E->getType()); 216c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman 217592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson return EmitCastExpr(E); 2187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 219d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *EmitCastExpr(CastExpr *E); 2207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCallExpr(const CallExpr *E) { 222e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson if (E->getCallReturnType()->isReferenceType()) 223e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson return EmitLoadOfLValue(E); 224db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2259b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitCallExpr(E).getScalarVal(); 2267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2278f2926b73ed635afecd020da787af6a837601a2bDaniel Dunbar 2283379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner Value *VisitStmtExpr(const StmtExpr *E); 2294e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump 230a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike Stump Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E); 231db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Unary Operators. 2337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostDec(const UnaryOperator *E) { 2348c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2358c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, false); 2367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostInc(const UnaryOperator *E) { 2388c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2398c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, false); 2407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreDec(const UnaryOperator *E) { 2428c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2438c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, true); 2447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreInc(const UnaryOperator *E) { 2468c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2478c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, true); 2487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2498c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2508c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 2518c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre); 2528c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2538c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryAddrOf(const UnaryOperator *E) { 255d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // If the sub-expression is an instance member reference, 256d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // EmitDeclRefLValue will magically emit it with the appropriate 257d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // value as the "address". 2587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLValue(E->getSubExpr()).getAddress(); 2597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 2617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPlus(const UnaryOperator *E) { 2627f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // This differs from gcc, though, most likely due to a bug in gcc. 2637f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 2647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 2657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryMinus (const UnaryOperator *E); 2677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryNot (const UnaryOperator *E); 2687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryLNot (const UnaryOperator *E); 26946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryReal (const UnaryOperator *E); 27046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryImag (const UnaryOperator *E); 2717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryExtension(const UnaryOperator *E) { 2727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 2737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2748ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 2755f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson // C++ 27604421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 27704421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 27804421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 2795f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson Value *VisitCXXThisExpr(CXXThisExpr *TE) { 2805f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson return CGF.LoadCXXThis(); 281db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 282db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2837f6ad153565245026c7569314f65a4d4ff4ac41fAnders Carlsson Value *VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { 2843082463f4f387b725f4e4bf7d7b46269d445e4f5Anders Carlsson return CGF.EmitCXXExprWithTemporaries(E).getScalarVal(); 2857f6ad153565245026c7569314f65a4d4ff4ac41fAnders Carlsson } 286a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson Value *VisitCXXNewExpr(const CXXNewExpr *E) { 287a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson return CGF.EmitCXXNewExpr(E); 288a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson } 28960e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) { 29060e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson CGF.EmitCXXDeleteExpr(E); 29160e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson return 0; 29260e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson } 2939dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman Value *VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 2940dfd848fa4c9664852ba8c929a8bd3fce93ddca2Sebastian Redl return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue()); 2959dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman } 296db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 297a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) { 298a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // C++ [expr.pseudo]p1: 299db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // The result shall only be used as the operand for the function call 300a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // operator (), and the result of such a call has type void. The only 301a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // effect is the evaluation of the postfix-expression before the dot or 302a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // arrow. 303a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor CGF.EmitScalarExpr(E->getBase()); 304a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor return 0; 305a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor } 306db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 307c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 308a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 309c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson } 310756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 311756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson Value *VisitCXXThrowExpr(const CXXThrowExpr *E) { 312756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson CGF.EmitCXXThrowExpr(E); 313756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson return 0; 314756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson } 315756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 31698294def01c97e127fa6d812ebd944d37212828aSebastian Redl Value *VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) { 31798294def01c97e127fa6d812ebd944d37212828aSebastian Redl return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue()); 31898294def01c97e127fa6d812ebd944d37212828aSebastian Redl } 31998294def01c97e127fa6d812ebd944d37212828aSebastian Redl 3207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Binary Operators. 3217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitMul(const BinOpInfo &Ops) { 322f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 323a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 324a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 325a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul"); 326a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 327a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 328a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 329a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 330a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 331a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 332a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 333f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 33487415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul"); 3357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 3367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3378023030f76d334355b73d9c675d3870858aaf4fdChris Lattner bool isTrapvOverflowBehavior() { 3388023030f76d334355b73d9c675d3870858aaf4fdChris Lattner return CGF.getContext().getLangOptions().getSignedOverflowBehavior() 3398023030f76d334355b73d9c675d3870858aaf4fdChris Lattner == LangOptions::SOB_Trapping; 3408023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 3412add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Create a binary op that checks for overflow. 3422add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Currently only supports +, - and *. 3432add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); 3448023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Emit the overflow BB when -ftrapv option is activated. 3458023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitOverflowBB(llvm::BasicBlock *overflowBB) { 3468023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(overflowBB); 3478023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Function *Trap = CGF.CGM.getIntrinsic(llvm::Intrinsic::trap); 3488023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCall(Trap); 3498023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateUnreachable(); 3508023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 3518023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Check for undefined division and modulus behaviors. 3528023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops, 3538023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero,bool isDiv); 3547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitDiv(const BinOpInfo &Ops); 3557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitRem(const BinOpInfo &Ops); 3567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAdd(const BinOpInfo &Ops); 3577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitSub(const BinOpInfo &Ops); 3587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShl(const BinOpInfo &Ops); 3597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShr(const BinOpInfo &Ops); 3607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAnd(const BinOpInfo &Ops) { 3617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 3627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitXor(const BinOpInfo &Ops) { 3647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 3657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitOr (const BinOpInfo &Ops) { 3677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 3687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3701f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo EmitBinOps(const BinaryOperator *E); 3716a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 3726a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*F)(const BinOpInfo &), 373d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result); 3746a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 3753ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *EmitCompoundAssign(const CompoundAssignOperator *E, 3761f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 3771f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 3781f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Binary operators and binary compound assignment operators. 3791f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#define HANDLEBINOP(OP) \ 3803ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP(const BinaryOperator *E) { \ 3813ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return Emit ## OP(EmitBinOps(E)); \ 3823ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner } \ 3833ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 3843ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 3851f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 3867177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Mul) 3877177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Div) 3887177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Rem) 3897177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Add) 3907177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Sub) 3917177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shl) 3927177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shr) 3937177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(And) 3947177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Xor) 3957177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Or) 3961f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#undef HANDLEBINOP 3978c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 3987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Comparisons. 3997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 4007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc); 4017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#define VISITCOMP(CODE, UI, SI, FP) \ 4027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBin##CODE(const BinaryOperator *E) { \ 4037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 4047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::FCmpInst::FP); } 4057177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT) 4067177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT) 4077177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE) 4087177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE) 4097177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ) 4107177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE) 4117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#undef VISITCOMP 412db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinAssign (const BinaryOperator *E); 4147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLAnd (const BinaryOperator *E); 4167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLOr (const BinaryOperator *E); 4177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinComma (const BinaryOperator *E); 4187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 41925b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); } 42025b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); } 42125b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman 4227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Other Operators. 423df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump Value *VisitBlockExpr(const BlockExpr *BE); 4247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitConditionalOperator(const ConditionalOperator *CO); 4257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitChooseExpr(ChooseExpr *CE); 4267c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson Value *VisitVAArgExpr(VAArgExpr *VE); 4277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 4287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return CGF.EmitObjCStringLiteral(E); 4297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 4317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} // end anonymous namespace. 4327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 4347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Utilities 4357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 4367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4379abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner/// EmitConversionToBool - Convert the specified expression value to a 4383420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner/// boolean (i1) truth value. This is equivalent to "Val != 0". 4399abc84e7ac4db891209fe67cc3a8c9690dc886efChris LattnerValue *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 440467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs"); 441db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4429abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner if (SrcType->isRealFloatingType()) { 4439abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Compare against 0.0 for fp scalars. 444c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 4459abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Builder.CreateFCmpUNE(Src, Zero, "tobool"); 4469abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 447db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4480bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType)) 4490bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT); 450db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 451d1d66bcd6914ff82abdfa88dd25bb0b74cde3b99Daniel Dunbar assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 4529abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner "Unknown scalar type to convert"); 453db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4549abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Because of the type rules of C, we often end up computing a logical value, 4559abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // then zero extending it to int, then wanting it as a logical value again. 4569abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Optimize this common case. 4579abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(Src)) { 4580032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson if (ZI->getOperand(0)->getType() == 4590032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::Type::getInt1Ty(CGF.getLLVMContext())) { 4609abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner Value *Result = ZI->getOperand(0); 461356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // If there aren't any more uses, zap the instruction to save space. 462356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // Note that there can be more uses, for example if this 463356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // is the result of an assignment. 464356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman if (ZI->use_empty()) 465356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman ZI->eraseFromParent(); 4669abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Result; 4679abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 4689abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 469db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4709abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Compare against an integer or pointer null. 471c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 4729abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Builder.CreateICmpNE(Src, Zero, "tobool"); 4739abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner} 4749abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 4753707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 4763707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 4774f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 4784f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstType) { 4799619662a1d42e2008b865d3459c0677e149dad1bChris Lattner SrcType = CGF.getContext().getCanonicalType(SrcType); 4809619662a1d42e2008b865d3459c0677e149dad1bChris Lattner DstType = CGF.getContext().getCanonicalType(DstType); 4813707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (SrcType == DstType) return Src; 482db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 483cf289083ab007264fa3ea96d92f133339aee5d2dChris Lattner if (DstType->isVoidType()) return 0; 484db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4853707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 486ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstType->isBooleanType()) 487ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return EmitConversionToBool(Src, SrcType); 488db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4893707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner const llvm::Type *DstTy = ConvertType(DstType); 4903707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4913707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Ignore conversions like int -> uint. 4923707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (Src->getType() == DstTy) 4933707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Src; 4943707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 495db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle pointer conversions next: pointers can only be converted to/from 496db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // other pointers and integers. Check for pointer types in terms of LLVM, as 497db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // some native types (like Obj-C id) may map to a pointer type. 498270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(DstTy)) { 4993707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // The source value may be an integer, or a pointer. 500191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson if (isa<llvm::PointerType>(Src->getType())) 5013707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Builder.CreateBitCast(Src, DstTy, "conv"); 502191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 5033707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 50425615424741bcce31fe52c896f76268f0307f00dEli Friedman // First, convert to the correct width so that we control the kind of 50525615424741bcce31fe52c896f76268f0307f00dEli Friedman // extension. 50677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 50725615424741bcce31fe52c896f76268f0307f00dEli Friedman bool InputSigned = SrcType->isSignedIntegerType(); 50825615424741bcce31fe52c896f76268f0307f00dEli Friedman llvm::Value* IntResult = 50925615424741bcce31fe52c896f76268f0307f00dEli Friedman Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 51025615424741bcce31fe52c896f76268f0307f00dEli Friedman // Then, cast to pointer. 51125615424741bcce31fe52c896f76268f0307f00dEli Friedman return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 5123707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 513db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 514270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(Src->getType())) { 5153707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Must be an ptr to int cast. 5163707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 51750b5a30db40322880340e957ad7d6d8d60bb4c5bAnders Carlsson return Builder.CreatePtrToInt(Src, DstTy, "conv"); 5183707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 519db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 520213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // A scalar can be splatted to an extended vector of the same element type 5212ef13e5abef0570a9f567b4671367275c05d4d34Nate Begeman if (DstType->isExtVectorType() && !SrcType->isVectorType()) { 5226fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Cast the scalar to element type 523183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType EltTy = DstType->getAs<ExtVectorType>()->getElementType(); 5246fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 5256fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 5266fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Insert the element in element zero of an undef vector 52703e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::Value *UnV = llvm::UndefValue::get(DstTy); 52877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 5296fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 5306fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 5316fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Splat the element across to all elements 5326fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 5336fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 5346fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman for (unsigned i = 0; i < NumElements; i++) 53577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 0)); 536db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5374a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 5386fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 5396fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman return Yay; 5406fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman } 5414119d1aeca8016654d381ce079864058d1709571Nate Begeman 5423b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner // Allow bitcast from vector to integer/fp of the same size. 5437019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson if (isa<llvm::VectorType>(Src->getType()) || 5443b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner isa<llvm::VectorType>(DstTy)) 5457019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson return Builder.CreateBitCast(Src, DstTy, "conv"); 546db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5473707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Finally, we have the arithmetic types: real int/float. 5483707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(Src->getType())) { 5493707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner bool InputSigned = SrcType->isSignedIntegerType(); 550b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (isa<llvm::IntegerType>(DstTy)) 551b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 552b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else if (InputSigned) 553b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateSIToFP(Src, DstTy, "conv"); 554b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 555b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateUIToFP(Src, DstTy, "conv"); 5563707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 557db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 558f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(Src->getType()->isFloatingPointTy() && "Unknown real conversion"); 5593707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(DstTy)) { 560b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstType->isSignedIntegerType()) 561b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToSI(Src, DstTy, "conv"); 562b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 563b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToUI(Src, DstTy, "conv"); 5643707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 5653707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 566f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(DstTy->isFloatingPointTy() && "Unknown real conversion"); 567b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstTy->getTypeID() < Src->getType()->getTypeID()) 568b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPTrunc(Src, DstTy, "conv"); 569b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 570b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPExt(Src, DstTy, "conv"); 5713707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 5723707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 573db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 574db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 575db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 5764f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter:: 5774f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerEmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 5784f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy) { 579ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Get the source element type. 580183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall SrcTy = SrcTy->getAs<ComplexType>()->getElementType(); 581db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 582ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 583ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstTy->isBooleanType()) { 584ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Complex != 0 -> (Real != 0) | (Imag != 0) 585ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 586ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 587ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return Builder.CreateOr(Src.first, Src.second, "tobool"); 588ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner } 589db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5904f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 5914f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // the imaginary part of the complex value is discarded and the value of the 5924f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // real part is converted according to the conversion rules for the 593db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // corresponding real type. 5944f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return EmitScalarConversion(Src.first, SrcTy, DstTy); 5954f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 5964f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 597a40a9f31218c743e366322e34b59f0d4d4414198Anders CarlssonValue *ScalarExprEmitter::EmitNullValue(QualType Ty) { 5980bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) 5990bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 6000bab0cdab751248ca389a5592bcb70eac5d39260John McCall 6010bab0cdab751248ca389a5592bcb70eac5d39260John McCall return llvm::Constant::getNullValue(ConvertType(Ty)); 602a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson} 6034f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 6047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Visitor Methods 6067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitExpr(Expr *E) { 609488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGF.ErrorUnsupported(E, "scalar expression"); 6107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getType()->isVoidType()) 6117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 61203e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 6137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 6147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 615d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanValue *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 61637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Vector Mask Case 61737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 2 || 6183f4cb120fe574f7b80864f52a1999502a4f3a83dRafael Espindola (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { 61977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *LHS = CGF.EmitScalarExpr(E->getExpr(0)); 62077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *RHS = CGF.EmitScalarExpr(E->getExpr(1)); 62177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Mask; 62237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 62337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType()); 62437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman unsigned LHSElts = LTy->getNumElements(); 62537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 62637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 3) { 62737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = CGF.EmitScalarExpr(E->getExpr(2)); 62837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 62937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Shuffle LHS & RHS into one input vector. 63037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> concat; 63137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0; i != LHSElts; ++i) { 63277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i)); 63377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i+1)); 63437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 63537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 63637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* CV = llvm::ConstantVector::get(concat.begin(), concat.size()); 63737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); 63837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHSElts *= 2; 63937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } else { 64037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = RHS; 64137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 64237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 64337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType()); 64437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant* EltMask; 64537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 64637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Treat vec3 like vec4. 64737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) 64837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 64937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+2))-1); 65037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else if ((LHSElts == 3) && (E->getNumSubExprs() == 2)) 65137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 65237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+1))-1); 65337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else 65437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 65537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts))-1); 65637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 65737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Mask off the high bits of each shuffle index. 65837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant *, 32> MaskV; 65937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) 66037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MaskV.push_back(EltMask); 66137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 66237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* MaskBits = llvm::ConstantVector::get(MaskV.begin(), MaskV.size()); 66337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); 66437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 66537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = undef 66637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // mask = mask & maskbits 66737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // for each elt 66837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // n = extract mask i 66937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // x = extract val n 67037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = insert newv, x, i 67137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(), 67237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MTy->getNumElements()); 67337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* NewV = llvm::UndefValue::get(RTy); 67437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) { 67577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Indx = llvm::ConstantInt::get(CGF.Int32Ty, i); 67637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateExtractElement(Mask, Indx, "shuf_idx"); 67777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext"); 67837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 67937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 68037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { 68137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *cmpIndx, *newIndx; 68277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner cmpIndx = Builder.CreateICmpUGT(Indx, 68377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(CGF.Int32Ty, 3), 68437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "cmp_shuf_idx"); 68577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner newIndx = Builder.CreateSub(Indx, llvm::ConstantInt::get(CGF.Int32Ty,1), 68637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "shuf_idx_adj"); 68737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx"); 68837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 68937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt"); 69037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman NewV = Builder.CreateInsertElement(NewV, VExt, Indx, "shuf_ins"); 69137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 69237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman return NewV; 693d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 69437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 695d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 696d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 69737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 69837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 69937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> indices; 70037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 70137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant *C = cast<llvm::Constant>(CGF.EmitScalarExpr(E->getExpr(i))); 70237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *VTy = cast<llvm::VectorType>(V1->getType()); 70337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (VTy->getNumElements() == 3) { 70437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C)) { 70537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman uint64_t cVal = CI->getZExtValue(); 70637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (cVal > 3) { 70737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman C = llvm::ConstantInt::get(C->getType(), cVal-1); 70837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 70937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 71037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 71137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman indices.push_back(C); 71237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 71337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 7144a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson Value* SV = llvm::ConstantVector::get(indices.begin(), indices.size()); 715d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 716d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 71728665272c36cccb1014a6ea1217354b0519e2b59Eli FriedmanValue *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) { 71828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 71928665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 72028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->isArrow()) 72128665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman CGF.EmitScalarExpr(E->getBase()); 72228665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman else 72328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman EmitLValue(E->getBase()); 72428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 72528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 72678ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel 72778ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // Emit debug info for aggregate now, if it was delayed to reduce 72878ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // debug info size. 72978ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel CGDebugInfo *DI = CGF.getDebugInfo(); 73078ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (DI && CGF.CGM.getCodeGenOpts().LimitDebugInfo) { 73178ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel QualType PQTy = E->getBase()->IgnoreParenImpCasts()->getType(); 73278ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (const PointerType * PTy = dyn_cast<PointerType>(PQTy)) 73349c8465f14fc3b2e1a32c7016ad3fb4e2cf8d466Devang Patel if (FieldDecl *M = dyn_cast<FieldDecl>(E->getMemberDecl())) 73478ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel DI->getOrCreateRecordType(PTy->getPointeeType(), 73578ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel M->getParent()->getLocation()); 7367fa8ab2e77f5703d0adf14e4d98f1edc1e66505dDevang Patel } 73728665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return EmitLoadOfLValue(E); 73828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman} 739d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 7407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 7417f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 7427f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 7437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Emit subscript expressions in rvalue context's. For most cases, this just 7447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // loads the lvalue formed by the subscript expr. However, we have to be 7457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // careful, because the base of a vector subscript is occasionally an rvalue, 7467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // so we can't get it as an lvalue. 7477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (!E->getBase()->getType()->isVectorType()) 7487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 749db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 7507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the vector case. The base must be a vector, the index must be an 7517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // integer value. 7527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Base = Visit(E->getBase()); 7537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Idx = Visit(E->getIdx()); 754daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman bool IdxSigned = E->getIdx()->getType()->isSignedIntegerType(); 75577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast"); 7567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateExtractElement(Base, Idx, "vecext"); 7577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 7587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7590533b3020ca39898751d4200feed776861dcd1ceNate Begemanstatic llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, 7600533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned Off, const llvm::Type *I32Ty) { 7610533b3020ca39898751d4200feed776861dcd1ceNate Begeman int MV = SVI->getMaskValue(Idx); 7620533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (MV == -1) 7630533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::UndefValue::get(I32Ty); 7640533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::ConstantInt::get(I32Ty, Off+MV); 7650533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 7660533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7670533b3020ca39898751d4200feed776861dcd1ceNate BegemanValue *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { 7680533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool Ignore = TestAndClearIgnoreResultAssign(); 7690533b3020ca39898751d4200feed776861dcd1ceNate Begeman (void)Ignore; 7700533b3020ca39898751d4200feed776861dcd1ceNate Begeman assert (Ignore == false && "init list ignored"); 7710533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned NumInitElements = E->getNumInits(); 7720533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7730533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (E->hadArrayRangeDesignator()) 7740533b3020ca39898751d4200feed776861dcd1ceNate Begeman CGF.ErrorUnsupported(E, "GNU array range designator extension"); 7750533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7760533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VType = 7770533b3020ca39898751d4200feed776861dcd1ceNate Begeman dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 7780533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7790533b3020ca39898751d4200feed776861dcd1ceNate Begeman // We have a scalar in braces. Just use the first element. 7800533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VType) 7810533b3020ca39898751d4200feed776861dcd1ceNate Begeman return Visit(E->getInit(0)); 7820533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7830533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned ResElts = VType->getNumElements(); 7840533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7850533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Loop over initializers collecting the Value for each, and remembering 7860533b3020ca39898751d4200feed776861dcd1ceNate Begeman // whether the source was swizzle (ExtVectorElementExpr). This will allow 7870533b3020ca39898751d4200feed776861dcd1ceNate Begeman // us to fold the shuffle for the swizzle into the shuffle for the vector 7880533b3020ca39898751d4200feed776861dcd1ceNate Begeman // initializer, since LLVM optimizers generally do not want to touch 7890533b3020ca39898751d4200feed776861dcd1ceNate Begeman // shuffles. 7900533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned CurIdx = 0; 7910533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool VIsUndefShuffle = false; 7920533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *V = llvm::UndefValue::get(VType); 7930533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned i = 0; i != NumInitElements; ++i) { 7940533b3020ca39898751d4200feed776861dcd1ceNate Begeman Expr *IE = E->getInit(i); 7950533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Init = Visit(IE); 7960533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 7970533b3020ca39898751d4200feed776861dcd1ceNate Begeman 7980533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType()); 7990533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8000533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Handle scalar elements. If the scalar initializer is actually one 8010533b3020ca39898751d4200feed776861dcd1ceNate Begeman // element of a different vector of the same width, use shuffle instead of 8020533b3020ca39898751d4200feed776861dcd1ceNate Begeman // extract+insert. 8030533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VVT) { 8040533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 8050533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init); 8060533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8070533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (EI->getVectorOperandType()->getNumElements() == ResElts) { 8080533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand()); 8090533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *LHS = 0, *RHS = 0; 8100533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) { 8110533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undef -> shuffle (src, undef) 8120533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(C); 8130533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 1; j != ResElts; ++j) 81477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8150533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8160533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = EI->getVectorOperand(); 8170533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = V; 8180533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = true; 8190533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else if (VIsUndefShuffle) { 8200533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undefshuffle && size match -> shuffle (v, src) 8210533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V); 8220533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 82377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty)); 82477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 8250533b3020ca39898751d4200feed776861dcd1ceNate Begeman ResElts + C->getZExtValue())); 8260533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + 1; j != ResElts; ++j) 82777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8280533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8290533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 8300533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = EI->getVectorOperand(); 8310533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8320533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8330533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!Args.empty()) { 8340533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 8350533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(LHS, RHS, Mask); 8360533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8370533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8380533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8390533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8400533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 84177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 8420533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 8430533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8440533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8450533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8460533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8470533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8480533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned InitElts = VVT->getNumElements(); 8490533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8500533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's 8510533b3020ca39898751d4200feed776861dcd1ceNate Begeman // input is the same width as the vector being constructed, generate an 8520533b3020ca39898751d4200feed776861dcd1ceNate Begeman // optimized shuffle of the swizzle input into the result. 853a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman unsigned Offset = (CurIdx == 0) ? 0 : ResElts; 8540533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 8550533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init); 8560533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *SVOp = SVI->getOperand(0); 8570533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType()); 8580533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8590533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (OpTy->getNumElements() == ResElts) { 8600533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) { 8610533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the current vector initializer is a shuffle with undef, merge 8620533b3020ca39898751d4200feed776861dcd1ceNate Begeman // this shuffle directly into it. 8630533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) { 8640533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0, 86577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner CGF.Int32Ty)); 8660533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else { 86777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 8680533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8690533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8700533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0, je = InitElts; j != je; ++j) 87177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty)); 8720533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 87377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8740533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8750533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) 8760533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 8770533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8780533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = SVOp; 8790533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8800533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8810533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8820533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Extend init to result vector length, and then shuffle its contribution 8830533b3020ca39898751d4200feed776861dcd1ceNate Begeman // to the vector initializer into V. 8840533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (Args.empty()) { 8850533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 88677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 8870533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = InitElts; j != ResElts; ++j) 88877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8890533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 8900533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), 891a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman Mask, "vext"); 8920533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8930533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.clear(); 8940533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 89577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 8960533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 89777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j+Offset)); 8980533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 89977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9000533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9010533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9020533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If V is undef, make sure it ends up on the RHS of the shuffle to aid 9030533b3020ca39898751d4200feed776861dcd1ceNate Begeman // merging subsequent shuffles into this one. 9040533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) 9050533b3020ca39898751d4200feed776861dcd1ceNate Begeman std::swap(V, Init); 9060533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 9070533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit"); 9080533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = isa<llvm::UndefValue>(Init); 9090533b3020ca39898751d4200feed776861dcd1ceNate Begeman CurIdx += InitElts; 9100533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9110533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9120533b3020ca39898751d4200feed776861dcd1ceNate Begeman // FIXME: evaluate codegen vs. shuffling against constant null vector. 9130533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers. 9140533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::Type *EltTy = VType->getElementType(); 9150533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9160533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers 9170533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { 91877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 9190533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *Init = llvm::Constant::getNullValue(EltTy); 9200533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 9210533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9220533b3020ca39898751d4200feed776861dcd1ceNate Begeman return V; 9230533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 9240533b3020ca39898751d4200feed776861dcd1ceNate Begeman 925a3697c9c155bda93fd2802f37084b620f4738822Anders Carlssonstatic bool ShouldNullCheckClassCastValue(const CastExpr *CE) { 926a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const Expr *E = CE->getSubExpr(); 92723cba801e11b03929c44f8cf54578305963a3476John McCall 9282de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CE->getCastKind() == CK_UncheckedDerivedToBase) 92923cba801e11b03929c44f8cf54578305963a3476John McCall return false; 930a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 931a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (isa<CXXThisExpr>(E)) { 932a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // We always assume that 'this' is never null. 933a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 934a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 935a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 936a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) { 937906082edf2aea1c6de2926f93a8d7121e49d2a54Sebastian Redl // And that glvalue casts are never null. 9385baba9d98364a3525d6afa15a04cdad82fd6dd30John McCall if (ICE->getValueKind() != VK_RValue) 939a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 940a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 941a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 942a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return true; 943a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson} 944a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 945504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 946504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// have to handle a more broad range of conversions than explicit casts, as they 947504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// handle things like function to ptr-to-function decay etc. 948d888962cff03b543fbe9ac6051ec6addf5b993b4Eli FriedmanValue *ScalarExprEmitter::EmitCastExpr(CastExpr *CE) { 949d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Expr *E = CE->getSubExpr(); 950592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson QualType DestTy = CE->getType(); 9512de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CastKind Kind = CE->getCastKind(); 952592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson 953504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson if (!DestTy->isVoidType()) 954504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson TestAndClearIgnoreResultAssign(); 955db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 9568c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // Since almost all cast kinds apply to scalars, this switch doesn't have 9578c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // a default case, so the compiler will warn on a missing case. The cases 9588c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // are in the same order as in the CastKind enum. 959504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson switch (Kind) { 9602de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_Unknown: 961d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman // FIXME: All casts should have a known kind! 962ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman //assert(0 && "Unknown cast kind!"); 963504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson break; 964ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 9652de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_LValueBitCast: 9662de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ObjCObjectLValueCast: { 967e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor Value *V = EmitLValue(E).getAddress(); 968e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor V = Builder.CreateBitCast(V, 969e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor ConvertType(CGF.getContext().getPointerType(DestTy))); 9709f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), DestTy); 971e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor } 972e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor 9732de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_AnyPointerToObjCPointerCast: 9742de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_AnyPointerToBlockPointerCast: 9752de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BitCast: { 976cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 977cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson return Builder.CreateBitCast(Src, ConvertType(DestTy)); 978cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson } 9792de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NoOp: 9802de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UserDefinedConversion: 981ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Visit(const_cast<Expr*>(E)); 982db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 9832de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerived: { 984a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const CXXRecordDecl *DerivedClassDecl = 985a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson DestTy->getCXXRecordDeclForPointerType(); 986a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 987a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl, 988f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 989a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson ShouldNullCheckClassCastValue(CE)); 990a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 9912de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UncheckedDerivedToBase: 9922de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBase: { 993191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson const RecordType *DerivedClassTy = 994191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson E->getType()->getAs<PointerType>()->getPointeeType()->getAs<RecordType>(); 995191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson CXXRecordDecl *DerivedClassDecl = 996191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 997191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 99834a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, 999f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 100034a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson ShouldNullCheckClassCastValue(CE)); 1001191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson } 10022de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_Dynamic: { 10038c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman Value *V = Visit(const_cast<Expr*>(E)); 10048c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE); 10058c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman return CGF.EmitDynamicCast(V, DCE); 10068c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman } 10072de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ToUnion: 1008ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(0 && "Should be unreachable!"); 1009ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman break; 1010d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 10112de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ArrayToPointerDecay: { 1012ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(E->getType()->isArrayType() && 1013ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Array to pointer decay must have array source type!"); 1014ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1015ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *V = EmitLValue(E).getAddress(); // Bitfields can't be arrays. 1016ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1017ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Note that VLA pointers are always decayed, so we don't need to do 1018ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // anything here. 1019ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman if (!E->getType()->isVariableArrayType()) { 1020ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 1021ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 1022ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman ->getElementType()) && 1023ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Expected pointer to array"); 1024ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman V = Builder.CreateStructGEP(V, 0, "arraydecay"); 1025ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1026ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1027ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return V; 1028ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 10292de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FunctionToPointerDecay: 1030ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return EmitLValue(E).getAddress(); 1031ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 10322de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NullToMemberPointer: { 1033d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // If the subexpression's type is the C++0x nullptr_t, emit the 1034d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // subexpression, which may have side effects. 1035d608cdb7c044365cf4e8764ade1e11e99c176078John McCall if (E->getType()->isNullPtrType()) 1036d608cdb7c044365cf4e8764ade1e11e99c176078John McCall (void) Visit(E); 1037d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 10380bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>(); 10390bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 10400bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 1041191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 10422de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerivedMemberPointer: 10432de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBaseMemberPointer: { 1044d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *Src = Visit(E); 1045d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 1046d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // Note that the AST doesn't distinguish between checked and 1047d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // unchecked member pointer conversions, so we always have to 1048d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // implement checked conversions here. This is inefficient when 1049d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // actual control flow may be required in order to perform the 1050d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // check, which it is for data member pointers (but not member 1051d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // function pointers on Itanium and ARM). 10520bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src); 1053d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 10540bab0cdab751248ca389a5592bcb70eac5d39260John McCall 1055d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 10562de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ConstructorConversion: 1057d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman assert(0 && "Should be unreachable!"); 10588c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman break; 10598c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman 10602de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToPointer: { 10617f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 106289f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 106382debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // First, convert to the correct width so that we control the kind of 106482debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // extension. 106577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 106682debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson bool InputSigned = E->getType()->isSignedIntegerType(); 106782debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson llvm::Value* IntResult = 106882debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 106989f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 107082debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy)); 10717f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 10722de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_PointerToIntegral: { 10737f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 107489f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 107589f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar // Handle conversion to bool correctly. 107689f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar if (DestTy->isBooleanType()) 1077db50547fd526329d00fa1fee4e7ac90f2624c6e0Daniel Dunbar return EmitScalarConversion(Src, E->getType(), DestTy); 107889f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 10797f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson return Builder.CreatePtrToInt(Src, ConvertType(DestTy)); 10807f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 10812de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ToVoid: { 1082699c06068dab18efd37897659ec120d211827607Fariborz Jahanian if (E->Classify(CGF.getContext()).isGLValue()) { 1083699c06068dab18efd37897659ec120d211827607Fariborz Jahanian LValue LV = CGF.EmitLValue(E); 1084699c06068dab18efd37897659ec120d211827607Fariborz Jahanian if (LV.isPropertyRef()) 1085699c06068dab18efd37897659ec120d211827607Fariborz Jahanian CGF.EmitLoadOfPropertyRefLValue(LV, E->getType()); 1086699c06068dab18efd37897659ec120d211827607Fariborz Jahanian else if (LV.isKVCRef()) 1087699c06068dab18efd37897659ec120d211827607Fariborz Jahanian CGF.EmitLoadOfKVCRefLValue(LV, E->getType()); 1088699c06068dab18efd37897659ec120d211827607Fariborz Jahanian } 1089569c3166874324c24011f8ade6978421f0d39b3cDouglas Gregor else 1090558d2abc7f9fd6801cc7677200992313ae90b5d8John McCall CGF.EmitAnyExpr(E, AggValueSlot::ignored(), true); 1091ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return 0; 1092ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 10932de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_VectorSplat: { 1094ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman const llvm::Type *DstTy = ConvertType(DestTy); 1095ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *Elt = Visit(const_cast<Expr*>(E)); 1096ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1097ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Insert the element in element zero of an undef vector 1098ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *UnV = llvm::UndefValue::get(DstTy); 109977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 1100ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 1101ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1102ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Splat the element across to all elements 1103ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::SmallVector<llvm::Constant*, 16> Args; 1104ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 1105ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman for (unsigned i = 0; i < NumElements; i++) 110677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 0)); 1107ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1108ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 1109ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 1110ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Yay; 1111ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 11122de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralCast: 11132de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToFloating: 11142de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingToIntegral: 11152de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingCast: 1116d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return EmitScalarConversion(Visit(E), E->getType(), DestTy); 1117ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 11182de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_MemberPointerToBoolean: { 11190bab0cdab751248ca389a5592bcb70eac5d39260John McCall llvm::Value *MemPtr = Visit(E); 11200bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>(); 11210bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT); 1122e9776247577715ad3a19461769a3488a445a8cbdAnders Carlsson } 11230bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 11240bab0cdab751248ca389a5592bcb70eac5d39260John McCall 112558a2e944faa16f1f61439acd2e71b19f50189511Chris Lattner // Handle cases where the source is an non-complex type. 1126db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 112719a1d7c646729eb858b15583e647262a22de3637Chris Lattner if (!CGF.hasAggregateLLVMType(E->getType())) { 11283707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner Value *Src = Visit(const_cast<Expr*>(E)); 11293707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 11303707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Use EmitScalarConversion to perform the conversion. 11313707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return EmitScalarConversion(Src, E->getType(), DestTy); 11323707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 1133db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 11349b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (E->getType()->isAnyComplexType()) { 113519a1d7c646729eb858b15583e647262a22de3637Chris Lattner // Handle cases where the source is a complex type. 11367f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreImag = true; 11377f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreImagAssign = true; 11387f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreReal = IgnoreResultAssign; 11397f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreRealAssign = IgnoreResultAssign; 11407f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (DestTy->isBooleanType()) 11417f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreImagAssign = IgnoreImag = false; 11427f79f9be5916c51c35da4f126b7c12596a101607Mike Stump else if (DestTy->isVoidType()) { 11437f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreReal = IgnoreImag = false; 11447f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreRealAssign = IgnoreImagAssign = true; 11457f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } 11467f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CodeGenFunction::ComplexPairTy V 11477f79f9be5916c51c35da4f126b7c12596a101607Mike Stump = CGF.EmitComplexExpr(E, IgnoreReal, IgnoreImag, IgnoreRealAssign, 11487f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreImagAssign); 11497f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitComplexToScalarConversion(V, E->getType(), DestTy); 115019a1d7c646729eb858b15583e647262a22de3637Chris Lattner } 115110b00cfe6422906b223724048b9b2123968d3baaChris Lattner 115219a1d7c646729eb858b15583e647262a22de3637Chris Lattner // Okay, this is a cast from an aggregate. It must be a cast to void. Just 115319a1d7c646729eb858b15583e647262a22de3637Chris Lattner // evaluate the result and return. 1154558d2abc7f9fd6801cc7677200992313ae90b5d8John McCall CGF.EmitAggExpr(E, AggValueSlot::ignored(), true); 115519a1d7c646729eb858b15583e647262a22de3637Chris Lattner return 0; 11567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 11577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11583379320c10001d7e1ee5d7e7142c417f797cfe82Chris LattnerValue *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 115991d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner return CGF.EmitCompoundStmt(*E->getSubStmt(), 116091d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner !E->getType()->isVoidType()).getScalarVal(); 11613379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner} 11623379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 1163a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike StumpValue *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 1164f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian llvm::Value *V = CGF.GetAddrOfBlockDecl(E); 1165f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian if (E->getType().isObjCGCWeak()) 1166f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian return CGF.CGM.getObjCRuntime().EmitObjCWeakRead(CGF, V); 1167469a20de757ff872c90ff6b1134f6346909ff652Fariborz Jahanian return CGF.EmitLoadOfScalar(V, false, 0, E->getType()); 11684e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump} 11693379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 11707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 11717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Unary Operators 11727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 11737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11748c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *ScalarExprEmitter:: 11758c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 11768c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 11778c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11788c11a65c18ae607b7073e1e451264492d2297726Chris Lattner QualType ValTy = E->getSubExpr()->getType(); 11798c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *InVal = EmitLoadOfLValue(LV, ValTy); 11808c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11818c11a65c18ae607b7073e1e451264492d2297726Chris Lattner int AmountVal = isInc ? 1 : -1; 11828c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11838c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (ValTy->isPointerType() && 11848c11a65c18ae607b7073e1e451264492d2297726Chris Lattner ValTy->getAs<PointerType>()->isVariableArrayType()) { 11858c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // The amount of the addition/subtraction needs to account for the VLA size 11868c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.ErrorUnsupported(E, "VLA pointer inc/dec"); 11878c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 11888c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 11898c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *NextVal; 11908c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (const llvm::PointerType *PT = 11918c11a65c18ae607b7073e1e451264492d2297726Chris Lattner dyn_cast<llvm::PointerType>(InVal->getType())) { 119277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Constant *Inc = llvm::ConstantInt::get(CGF.Int32Ty, AmountVal); 11938c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (!isa<llvm::FunctionType>(PT->getElementType())) { 11948c11a65c18ae607b7073e1e451264492d2297726Chris Lattner QualType PTEE = ValTy->getPointeeType(); 11958c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (const ObjCObjectType *OIT = PTEE->getAs<ObjCObjectType>()) { 11968c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Handle interface types, which are not represented with a concrete 11978c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // type. 11988c11a65c18ae607b7073e1e451264492d2297726Chris Lattner int size = CGF.getContext().getTypeSize(OIT) / 8; 11998c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (!isInc) 12008c11a65c18ae607b7073e1e451264492d2297726Chris Lattner size = -size; 12018c11a65c18ae607b7073e1e451264492d2297726Chris Lattner Inc = llvm::ConstantInt::get(Inc->getType(), size); 12028c11a65c18ae607b7073e1e451264492d2297726Chris Lattner const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 12038c11a65c18ae607b7073e1e451264492d2297726Chris Lattner InVal = Builder.CreateBitCast(InVal, i8Ty); 12048c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateGEP(InVal, Inc, "add.ptr"); 12058c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *lhs = LV.getAddress(); 12068c11a65c18ae607b7073e1e451264492d2297726Chris Lattner lhs = Builder.CreateBitCast(lhs, llvm::PointerType::getUnqual(i8Ty)); 12079f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar LV = CGF.MakeAddrLValue(lhs, ValTy); 12088c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else 12098c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateInBoundsGEP(InVal, Inc, "ptrincdec"); 12108c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 12118c11a65c18ae607b7073e1e451264492d2297726Chris Lattner const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 12128c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateBitCast(InVal, i8Ty, "tmp"); 12138c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateGEP(NextVal, Inc, "ptrincdec"); 12148c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateBitCast(NextVal, InVal->getType()); 12158c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 12168c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else if (InVal->getType()->isIntegerTy(1) && isInc) { 12178c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool++ is an interesting case, due to promotion rules, we get: 12188c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool++ -> Bool = Bool+1 -> Bool = (int)Bool+1 -> 12198c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool = ((int)Bool+1) != 0 12208c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // An interesting aspect of this is that increment is always true. 12218c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Decrement does not have this property. 12228c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantInt::getTrue(VMContext); 12238c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else if (isa<llvm::IntegerType>(InVal->getType())) { 12248c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal); 12258c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 1226640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner if (!ValTy->isSignedIntegerType()) 1227640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner // Unsigned integer inc is always two's complement. 12288c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1229640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner else { 1230640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1231640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Undefined: 1232640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner NextVal = Builder.CreateNSWAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1233640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner break; 1234640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Defined: 1235640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1236640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner break; 1237640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Trapping: 1238640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOpInfo BinOp; 1239640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.LHS = InVal; 1240640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.RHS = NextVal; 1241640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.Ty = E->getType(); 12422de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall BinOp.Opcode = BO_Add; 1243640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.E = E; 1244401be6bddcf05ac2828730e0bb4e8b81931f8296John McCall NextVal = EmitOverflowCheckedBinOp(BinOp); 1245401be6bddcf05ac2828730e0bb4e8b81931f8296John McCall break; 1246640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner } 1247640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner } 12488c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 12498c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Add the inc/dec to the real part. 12508c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (InVal->getType()->isFloatTy()) 12518c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = 12528c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::ConstantFP::get(VMContext, 12538c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat(static_cast<float>(AmountVal))); 12548c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else if (InVal->getType()->isDoubleTy()) 12558c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = 12568c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::ConstantFP::get(VMContext, 12578c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat(static_cast<double>(AmountVal))); 12588c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else { 12598c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat F(static_cast<float>(AmountVal)); 12608c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool ignored; 12618c11a65c18ae607b7073e1e451264492d2297726Chris Lattner F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 12628c11a65c18ae607b7073e1e451264492d2297726Chris Lattner &ignored); 12638c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantFP::get(VMContext, F); 12648c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 12658c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateFAdd(InVal, NextVal, isInc ? "inc" : "dec"); 12668c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 12678c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12688c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Store the updated result through the lvalue. 12698c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (LV.isBitField()) 12708c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.EmitStoreThroughBitfieldLValue(RValue::get(NextVal), LV, ValTy, &NextVal); 12718c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else 12728c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.EmitStoreThroughLValue(RValue::get(NextVal), LV, ValTy); 12738c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12748c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // If this is a postinc, return the value read from memory, otherwise use the 12758c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // updated value. 12768c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return isPre ? NextVal : InVal; 12778c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 12788c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12798c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12808c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 12827f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 12839a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Emit unary minus with EmitSub so we handle overflow cases etc. 12849a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOpInfo BinOp; 12854ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.RHS = Visit(E->getSubExpr()); 12864ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner 12874ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner if (BinOp.RHS->getType()->isFPOrFPVectorTy()) 12884ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType()); 12894ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner else 12904ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType()); 12919a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.Ty = E->getType(); 12922de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall BinOp.Opcode = BO_Sub; 12939a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.E = E; 12949a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner return EmitSub(BinOp); 12957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 12987f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 12997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 13007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNot(Op, "neg"); 13017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 13047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Compare operand to zero. 13057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 1306db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 13077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Invert value. 13087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // TODO: Could dynamically modify easy computations here. For example, if 13097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // the operand is an icmp ne, turn into icmp eq. 13107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BoolVal = Builder.CreateNot(BoolVal, "lnot"); 1311db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 13129f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson // ZExt result to the expr type. 13139f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext"); 13147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13160027d2bb24db629a33a71d04a5fb90a14c15a680Eli FriedmanValue *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) { 13170027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Try folding the offsetof to a constant. 13180027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr::EvalResult EvalResult; 13190027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (E->Evaluate(EvalResult, CGF.getContext())) 13200027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman return llvm::ConstantInt::get(VMContext, EvalResult.Val.getInt()); 13210027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13220027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Loop over the components of the offsetof to compute the value. 13230027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned n = E->getNumComponents(); 13240027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const llvm::Type* ResultType = ConvertType(E->getType()); 13250027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Result = llvm::Constant::getNullValue(ResultType); 13260027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman QualType CurrentType = E->getTypeSourceInfo()->getType(); 13270027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (unsigned i = 0; i != n; ++i) { 13280027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman OffsetOfExpr::OffsetOfNode ON = E->getComponent(i); 132916fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman llvm::Value *Offset = 0; 13300027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman switch (ON.getKind()) { 13310027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Array: { 13320027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index 13330027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex()); 13340027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr); 13350027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman bool IdxSigned = IdxExpr->getType()->isSignedIntegerType(); 13360027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv"); 13370027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13380027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type 13390027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = 13400027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getAsArrayType(CurrentType)->getElementType(); 13410027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13420027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the element size 13430027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType, 13440027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity()); 13450027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13460027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Multiply out to compute the result 13470027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = Builder.CreateMul(Idx, ElemSize); 13480027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 13490027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 13500027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13510027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Field: { 13520027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldDecl *MemberDecl = ON.getField(); 13530027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 13540027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 13550027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13560027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index of the field in its parent. 13570027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned i = 0; 13580027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // FIXME: It would be nice if we didn't have to loop here! 13590027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (RecordDecl::field_iterator Field = RD->field_begin(), 13600027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldEnd = RD->field_end(); 13610027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Field != FieldEnd; (void)++Field, ++i) { 13620027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (*Field == MemberDecl) 13630027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 13640027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 13650027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman assert(i < RL.getFieldCount() && "offsetof field in wrong type"); 13660027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13670027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the field 13680027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman int64_t OffsetInt = RL.getFieldOffset(i) / 13690027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 13700027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 13710027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13720027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 13730027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = MemberDecl->getType(); 13740027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 13750027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 137616fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 13770027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Identifier: 13786d4e44b462fe9e870a40358522379400ccc6e3c2Eli Friedman llvm_unreachable("dependent __builtin_offsetof"); 137916fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 13800027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Base: { 13810027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (ON.getBase()->isVirtual()) { 13820027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.ErrorUnsupported(E, "virtual base in offsetof"); 13830027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman continue; 13840027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 13850027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13860027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 13870027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 13880027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13890027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 13900027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = ON.getBase()->getType(); 13910027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13920027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the base. 13930027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const RecordType *BaseRT = CurrentType->getAs<RecordType>(); 13940027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl()); 13950027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman int64_t OffsetInt = RL.getBaseClassOffset(BaseRD) / 13960027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 13970027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 13980027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 13990027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14000027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14010027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Result = Builder.CreateAdd(Result, Offset); 14020027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14030027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman return Result; 14048ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor} 14058ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 14060518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// VisitSizeOfAlignOfExpr - Return the size or alignment of the type of 14070518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// argument of the sizeof expression as an integer. 14080518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlValue * 14090518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) { 14100518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl QualType TypeToSize = E->getTypeOfArgument(); 1411f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isSizeOf()) { 1412db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (const VariableArrayType *VAT = 1413f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.getContext().getAsVariableArrayType(TypeToSize)) { 1414f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isArgumentType()) { 1415f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // sizeof(type) - make sure to emit the VLA size. 1416f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.EmitVLASize(TypeToSize); 14178f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman } else { 14188f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // C99 6.5.3.4p2: If the argument is an expression of type 14198f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // VLA, it is evaluated. 14208f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman CGF.EmitAnyExpr(E->getArgumentExpr()); 1421f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman } 1422db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 142396f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson return CGF.GetVLASize(VAT); 1424b50525ba0e996bc072cdb76152fcfe0bc64bb72aAnders Carlsson } 14255d46315ca3cbbfe0d0f5f65520b618fb05dd4446Anders Carlsson } 1426f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman 1427db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If this isn't sizeof(vla), the result must be constant; use the constant 1428db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // folding logic so we don't have to duplicate it here. 1429f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman Expr::EvalResult Result; 1430f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman E->Evaluate(Result, CGF.getContext()); 14314a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 14327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 143446f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 143546f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 14369b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (Op->getType()->isAnyComplexType()) 14377f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return CGF.EmitComplexExpr(Op, false, true, false, true).first; 143846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return Visit(Op); 143946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 144046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 144146f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 14429b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (Op->getType()->isAnyComplexType()) 14437f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return CGF.EmitComplexExpr(Op, true, false, true, false).second; 1444db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 14457f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __imag on a scalar returns zero. Emit the subexpr to ensure side 14467f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // effects are evaluated, but not the actual value. 14477f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (E->isLvalue(CGF.getContext()) == Expr::LV_Valid) 14487f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitLValue(Op); 14497f79f9be5916c51c35da4f126b7c12596a101607Mike Stump else 14507f79f9be5916c51c35da4f126b7c12596a101607Mike Stump CGF.EmitScalarExpr(Op, true); 1451c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson return llvm::Constant::getNullValue(ConvertType(E->getType())); 145246f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 145346f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 14547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 14557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Binary Operators 14567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 14577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerBinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 14597f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 14607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BinOpInfo Result; 14617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.LHS = Visit(E->getLHS()); 14627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.RHS = Visit(E->getRHS()); 14631f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Result.Ty = E->getType(); 14649a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner Result.Opcode = E->getOpcode(); 14657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.E = E; 14667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Result; 14677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14696a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue ScalarExprEmitter::EmitCompoundAssignLValue( 14706a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E, 14716a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), 1472d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result) { 147354d76db0aa7107597cac0b80d8e138a37e6d1de9Benjamin Kramer QualType LHSTy = E->getLHS()->getType(); 14741f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo OpInfo; 14756a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1476ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman if (E->getComputationResultType()->isAnyComplexType()) { 1477db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // This needs to go through the complex expression emitter, but it's a tad 1478db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // complicated to do that... I'm leaving it out for now. (Note that we do 1479db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // actually need the imaginary part of the RHS for multiplication and 1480db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // division.) 1481ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman CGF.ErrorUnsupported(E, "complex compound assignment"); 1482d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = llvm::UndefValue::get(CGF.ConvertType(E->getType())); 14836a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LValue(); 14841f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 14856a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1486cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // Emit the RHS first. __block variables need to have the rhs evaluated 1487cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // first, plus this should improve codegen a little. 1488cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.RHS = Visit(E->getRHS()); 1489cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.Ty = E->getComputationResultType(); 14909a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OpInfo.Opcode = E->getOpcode(); 1491cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.E = E; 1492ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // Load/convert the LHS. 1493b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHSLV = EmitCheckedLValue(E->getLHS()); 1494ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy); 1495ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 1496ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman E->getComputationLHSType()); 14976a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 14981f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Expand the binary operator. 1499d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = (this->*Func)(OpInfo); 15006a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 15018c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Convert the result back to the LHS type. 1502ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 15036a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1504db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Store the result value into the LHS lvalue. Bit-fields are handled 1505db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // specially because the result is altered by the store, i.e., [C99 6.5.16p1] 1506db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // 'An assignment expression has the value of the left operand after the 1507db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // assignment...'. 1508d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHSLV.isBitField()) 1509d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy, 1510d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar &Result); 1511d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 1512ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy); 1513d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 15146a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LHSLV; 15156a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 15166a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 15176a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorValue *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 15186a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 15196a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor bool Ignore = TestAndClearIgnoreResultAssign(); 1520d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *RHS; 1521d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar LValue LHS = EmitCompoundAssignLValue(E, Func, RHS); 1522d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1523d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 15247f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 15257f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 1526d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1527d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 1528d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHS.isPropertyRef() || LHS.isKVCRef()) 1529d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1530d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1531d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 1532d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 1533d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1534d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1535d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 1536d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return EmitLoadOfLValue(LHS, E->getType()); 15371f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner} 15381f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 15398023030f76d334355b73d9c675d3870858aaf4fdChris Lattnervoid ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck( 15408023030f76d334355b73d9c675d3870858aaf4fdChris Lattner const BinOpInfo &Ops, 15418023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero, bool isDiv) { 15428023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 15438023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *contBB = 15448023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.createBasicBlock(isDiv ? "div.cont" : "rem.cont", CGF.CurFn); 15458023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 15468023030f76d334355b73d9c675d3870858aaf4fdChris Lattner const llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType()); 15478023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 15488023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->hasSignedIntegerRepresentation()) { 15498023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *IntMin = 15508023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::ConstantInt::get(VMContext, 15518023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::APInt::getSignedMinValue(Ty->getBitWidth())); 15528023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL); 15538023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 15548023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond1 = Builder.CreateICmpEQ(Ops.RHS, Zero); 15558023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *LHSCmp = Builder.CreateICmpEQ(Ops.LHS, IntMin); 15568023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *RHSCmp = Builder.CreateICmpEQ(Ops.RHS, NegOne); 15578023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond2 = Builder.CreateAnd(LHSCmp, RHSCmp, "and"); 15588023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCondBr(Builder.CreateOr(Cond1, Cond2, "or"), 15598023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 15608023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } else { 15618023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateICmpEQ(Ops.RHS, Zero), 15628023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 15638023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 15648023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 15658023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(contBB); 15668023030f76d334355b73d9c675d3870858aaf4fdChris Lattner} 15671f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 15687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 15698023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 15708023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 15718023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 15728023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 15738023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true); 15748023030f76d334355b73d9c675d3870858aaf4fdChris Lattner else if (Ops.Ty->isRealFloatingType()) { 15758023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", 15768023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.CurFn); 15778023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *DivCont = CGF.createBasicBlock("div.cont", CGF.CurFn); 15788023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero), 15798023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, DivCont); 15808023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 15818023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(DivCont); 15828023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 15838023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 1584f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 15857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 1586f60946222721d9ba3c059563935c17b84703187aDouglas Gregor else if (Ops.Ty->hasUnsignedIntegerRepresentation()) 15877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 15887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 15897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 15907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 15917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 15937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Rem in C can't be a floating point type: C99 6.5.5p2. 15948023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 15958023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 15968023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 15978023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 15988023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false); 15998023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 16008023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16011f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner if (Ops.Ty->isUnsignedIntegerType()) 16027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 16037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 16047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 16057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 16067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16072add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike StumpValue *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 16082add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned IID; 16092add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned OpID = 0; 16105d8b2cf9fd704f6ca5e33525803a65421c0b440eMike Stump 16119a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner switch (Ops.Opcode) { 16122de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 16132de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_AddAssign: 1614035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 1; 1615035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::sadd_with_overflow; 1616035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 16172de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 16182de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_SubAssign: 1619035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 2; 1620035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::ssub_with_overflow; 1621035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 16222de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 16232de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_MulAssign: 1624035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 3; 1625035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::smul_with_overflow; 1626035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1627035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump default: 1628035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump assert(false && "Unsupported operation for overflow detection"); 1629ab4eff620a9ce0ea62cdf29529a66c2c98d116f5Daniel Dunbar IID = 0; 1630035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump } 1631035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID <<= 1; 1632035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID |= 1; 1633035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump 16342add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 16352add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 16362add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1); 16372add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 16382add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 16392add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 16402add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 16412add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 16422add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Branch in case of overflow. 16437f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::BasicBlock *initialBB = Builder.GetInsertBlock(); 164493a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 164593a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn); 16462add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 16472add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateCondBr(overflow, overflowBB, continueBB); 16482add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 164993a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner // Handle overflow with llvm.trap. 16507f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall const std::string *handlerName = 16517f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall &CGF.getContext().getLangOptions().OverflowHandler; 16527f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall if (handlerName->empty()) { 16537f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall EmitOverflowBB(overflowBB); 16547f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(continueBB); 16557f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return result; 16567f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall } 16577f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 16587f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // If an overflow handler is set, then we want to call it and then use its 16597f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // result, if it returns. 16607f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(overflowBB); 16617f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 16627f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Get the overflow handler. 16637f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall const llvm::Type *Int8Ty = llvm::Type::getInt8Ty(VMContext); 16647f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall std::vector<const llvm::Type*> argTypes; 16657f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall argTypes.push_back(CGF.Int64Ty); argTypes.push_back(CGF.Int64Ty); 16667f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall argTypes.push_back(Int8Ty); argTypes.push_back(Int8Ty); 16677f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType *handlerTy = 16687f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType::get(CGF.Int64Ty, argTypes, true); 16697f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName); 16707f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 16717f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Sign extend the args to 64-bit, so that we can use the same handler for 16727f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // all types of overflow. 16737f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty); 16747f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty); 16757f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 16767f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Call the handler with the two arguments, the operation, and the size of 16777f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // the result. 16787f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handlerResult = Builder.CreateCall4(handler, lhs, rhs, 16797f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(OpID), 16807f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())); 16817f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 16827f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Truncate the result back to the desired size. 16837f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall handlerResult = Builder.CreateTrunc(handlerResult, opTy); 16847f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.CreateBr(continueBB); 16857f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 16862add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(continueBB); 16877f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::PHINode *phi = Builder.CreatePHI(opTy); 16887f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->reserveOperandSpace(2); 16897f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(result, initialBB); 16907f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(handlerResult, overflowBB); 16917f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 16927f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return phi; 16932add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump} 16947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { 169658f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (!Ops.Ty->isAnyPointerType()) { 1697f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 1698a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1699a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1700a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "add"); 1701a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1702a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 1703a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1704a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1705a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1706a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1707a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1708f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 170987415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFAdd(Ops.LHS, Ops.RHS, "add"); 1710bf933a0cb628670490c15367b3f5ccb3193354a7Dan Gohman 17117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 17122add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 1713daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 17147f215c12af4c3e7f81b24102a676aabfdb4e1566Chris Lattner // Must have binary (not unary) expr here. Unary pointer decrement doesn't 17159a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 17169a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 17179a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 171814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (Ops.Ty->isPointerType() && 17196217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek Ops.Ty->getAs<PointerType>()->isVariableArrayType()) { 1720daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size 17219a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer addition"); 1722daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 17239a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 17248f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Value *Ptr, *Idx; 17258f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Expr *IdxExp; 17269a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const PointerType *PT = BinOp->getLHS()->getType()->getAs<PointerType>(); 1727db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump const ObjCObjectPointerType *OPT = 17289a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<ObjCObjectPointerType>(); 172914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (PT || OPT) { 17308f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.LHS; 17318f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.RHS; 17329a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getRHS(); 173314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } else { // int + pointer 17349a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner PT = BinOp->getRHS()->getType()->getAs<PointerType>(); 17359a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OPT = BinOp->getRHS()->getType()->getAs<ObjCObjectPointerType>(); 173614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff assert((PT || OPT) && "Invalid add expr"); 17378f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.RHS; 17388f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.LHS; 17399a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getLHS(); 17408f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 17418f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner 17428f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 17437cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 17448f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // Zero or sign extend the pointer value based on whether the index is 17458f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // signed or not. 174677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *IdxType = CGF.IntPtrTy; 17479619662a1d42e2008b865d3459c0677e149dad1bChris Lattner if (IdxExp->getType()->isSignedIntegerType()) 17488f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 17498f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner else 17508f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 17518f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 175214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType ElementType = PT ? PT->getPointeeType() : OPT->getPointeeType(); 1753db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1754c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = ElementType->getAs<ObjCObjectType>()) { 1755db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 17564a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1757199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext().getTypeSizeInChars(OIT).getQuantity()); 17582a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 17593c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 17602a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 17612a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 17622a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1763db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 17642a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1765db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Explicitly handle GNU void* and function pointer arithmetic extensions. The 1766db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // GNU void* casts amount to no-ops since our void* type is i8*, but this is 1767db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // future proof. 1768b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (ElementType->isVoidType() || ElementType->isFunctionType()) { 17693c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1770b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 17712a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 1772b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1773db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1774db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1775664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ptr, Idx, "add.ptr"); 17767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { 17792add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump if (!isa<llvm::PointerType>(Ops.LHS->getType())) { 1780f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 1781a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1782a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1783a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub"); 1784a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1785a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 1786a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1787a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1788a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1789a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1790a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1791f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 179287415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFSub(Ops.LHS, Ops.RHS, "sub"); 17932eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner 17947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 17952add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 17961f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 17979a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Must have binary (not unary) expr here. Unary pointer increment doesn't 17989a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 17999a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 18009a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 18019a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner if (BinOp->getLHS()->getType()->isPointerType() && 18029a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<PointerType>()->isVariableArrayType()) { 1803daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size for 1804daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-int 1805daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the division needs to account for the VLA size for 1806daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-ptr. 18079a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer subtraction"); 1808daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 1809daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 18109a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const QualType LHSType = BinOp->getLHS()->getType(); 181114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType LHSElementType = LHSType->getPointeeType(); 18128c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar if (!isa<llvm::PointerType>(Ops.RHS->getType())) { 18138c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - int 18148c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *Idx = Ops.RHS; 18158c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 18167cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 18178c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Zero or sign extend the pointer value based on whether the index is 18188c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // signed or not. 181977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *IdxType = CGF.IntPtrTy; 18209a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner if (BinOp->getRHS()->getType()->isSignedIntegerType()) 18218c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 18228c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar else 18238c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 18248c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 18258c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateNeg(Idx, "sub.ptr.neg"); 1826b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar 1827db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1828c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = LHSElementType->getAs<ObjCObjectType>()) { 1829db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 18304a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1831199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext(). 1832199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getTypeSizeInChars(OIT).getQuantity()); 18332a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 18343c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 18352a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 18362a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr"); 18372a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1838db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 18392a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1840b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // Explicitly handle GNU void* and function pointer arithmetic 1841db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // extensions. The GNU void* casts amount to no-ops since our void* type is 1842db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // i8*, but this is future proof. 1843b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 18443c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1845b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1846b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr"); 1847b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1848db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1849db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1850664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ops.LHS, Idx, "sub.ptr"); 1851820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar } else { 18528c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - pointer 18538c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *LHS = Ops.LHS; 18548c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *RHS = Ops.RHS; 1855db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1856199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ElementSize; 1857820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar 1858e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Handle GCC extension for pointer arithmetic on void* and function pointer 1859e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // types. 1860e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 1861199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CharUnits::One(); 18628c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } else { 1863199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CGF.getContext().getTypeSizeInChars(LHSElementType); 18648c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 1865db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 18668c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar const llvm::Type *ResultType = ConvertType(Ops.Ty); 18678c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); 18688c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 18698c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 1870db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1871e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Optimize out the shift for element size of 1. 1872199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck if (ElementSize.isOne()) 1873e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner return BytesBetween; 1874df1109434abd465a4db2e6f69ec2688866660367Dan Gohman 1875df1109434abd465a4db2e6f69ec2688866660367Dan Gohman // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 1876db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // pointer difference in C is only defined in the case where both operands 1877db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // are pointing to elements of an array. 1878199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck Value *BytesPerElt = 1879199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck llvm::ConstantInt::get(ResultType, ElementSize.getQuantity()); 1880df1109434abd465a4db2e6f69ec2688866660367Dan Gohman return Builder.CreateExactSDiv(BytesBetween, BytesPerElt, "sub.ptr.div"); 18817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 18827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 18837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 18847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 18857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 18867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 18877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 18887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 18897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1890db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1891be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 1892be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1893be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1894be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1895be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1896be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 189715037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 1898be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 1899be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 1900be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 19017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateShl(Ops.LHS, RHS, "shl"); 19027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 19057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 19067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 19077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 19087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 19097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1910db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1911be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 1912be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1913be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1914be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1915be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1916be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 191715037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 1918be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 1919be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 1920be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 1921f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasUnsignedIntegerRepresentation()) 19227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 19237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 19247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 19277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc) { 19287f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 19294f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *Result; 19307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner QualType LHSTy = E->getLHS()->getType(); 19310bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) { 19322de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_EQ || 19332de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall E->getOpcode() == BO_NE); 1934d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *LHS = CGF.EmitScalarExpr(E->getLHS()); 1935d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *RHS = CGF.EmitScalarExpr(E->getRHS()); 19360bab0cdab751248ca389a5592bcb70eac5d39260John McCall Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison( 19372de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE); 1938b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else if (!LHSTy->isAnyComplexType()) { 19397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS = Visit(E->getLHS()); 19407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 1941db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1942f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (LHS->getType()->isFPOrFPVectorTy()) { 19437a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 19447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 1945f60946222721d9ba3c059563935c17b84703187aDouglas Gregor } else if (LHSTy->hasSignedIntegerRepresentation()) { 1946ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 19477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 19487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 1949ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman // Unsigned integers and pointers. 1950ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 19517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 19527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 19539c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner 19549c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // If this is a vector comparison, sign extend the result to the appropriate 19559c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // vector integer type and return it (don't convert to bool). 19569c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner if (LHSTy->isVectorType()) 19579c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 1958db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 19607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex Comparison: can only be an equality comparison. 19617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 19627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 1963db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1964183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType CETy = LHSTy->getAs<ComplexType>()->getElementType(); 1965db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19664f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *ResultR, *ResultI; 19677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (CETy->isRealFloatingType()) { 19687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 19697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 19707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 19717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 19727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 19737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex comparisons can only be equality comparisons. As such, signed 19747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // and unsigned opcodes are the same. 19757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 19767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 19777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 19787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 19797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1980db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19812de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (E->getOpcode() == BO_EQ) { 19827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 19837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 19842de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_NE && 19857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Complex comparison other than == or != ?"); 19867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 19877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 19887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 198932f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes 199032f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 19917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 19947f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool Ignore = TestAndClearIgnoreResultAssign(); 19957f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 19967f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __block variables need to have the rhs evaluated first, plus this should 19977f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // improve codegen just a little. 19987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 1999b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHS = EmitCheckedLValue(E->getLHS()); 2000db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2001ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar // Store the value into the LHS. Bit-fields are handled specially 2002371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // because the result is altered by the store, i.e., [C99 6.5.16p1] 2003371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // 'An assignment expression has the value of the left operand after 2004daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // the assignment...'. 2005d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHS.isBitField()) 2006d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType(), 2007d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar &RHS); 2008d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 2009ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType()); 2010d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2011d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 20127f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 20137f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 2014d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2015d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 2016d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHS.isPropertyRef() || LHS.isKVCRef()) 2017d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2018d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2019d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 2020d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 2021d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2022d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2023d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 20247f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitLoadOfLValue(LHS, E->getType()); 20257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 20277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 20287804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 20297804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 203020eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 203120eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 && X, just emit X without inserting the control flow. 203220eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 203320eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == 1) { // If we have 1 && X, just emit X. 20340946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 20357804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 20367804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 20370946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2038db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20397804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 204020eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 20417804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::Constant::getNullValue(ResTy); 20420946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2043db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20449615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 20459615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 204620eb09d562b80420a3328be789547af354bf3e36Chris Lattner 2047f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is false, go to the failure (cont) block. 2048f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 2049f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2050f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2051f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be false. Start 2052f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 20530032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 20540032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2055f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 2056f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2057f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 20583b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 2059db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 206072119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 20617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 20627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 206372119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 2064db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 20667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2067f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2068f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2069f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 20707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 20717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2072db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 20747804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 20757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 20777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 20787804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 20797804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 208020eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 208120eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 || X, just emit X without inserting the control flow. 208220eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 208320eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == -1) { // If we have 0 || X, just emit X. 20840946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 20857804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 20867804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 20870946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2088db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20897804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 209020eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 20917804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::ConstantInt::get(ResTy, 1); 20920946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2093db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 20949615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 20959615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 2096db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2097f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is true, go to the success (cont) block. 2098f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 2099f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2100f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2101f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be true. Start 2102f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 21030032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 21040032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2105f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 2106f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2107f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 21083b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 2109f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 211072119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 211133da07db112f4877f6ab13e20db08b9bb86a0c2eAnders Carlsson 2112f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit the RHS condition as a bool value. 21137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 21147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2115db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 211672119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 2117db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 21197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2120db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2121f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2122f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 2123f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBlock(ContBlock); 21247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2125db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 21277804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 21287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 21297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 21307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 21317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitStmt(E->getLHS()); 2132a448fb2da03ece39978784793eea68760e8205a1Daniel Dunbar CGF.EnsureInsertPoint(); 21337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getRHS()); 21347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 21357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 21367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 21377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Other Operators 21387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 21397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 21409802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 21419802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// expression is cheap enough and side-effect-free enough to evaluate 21429802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// unconditionally instead of conditionally. This is used to convert control 21439802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// flow into selects in some cases. 2144df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stumpstatic bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 2145df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CodeGenFunction &CGF) { 21469802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) 2147df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr(), CGF); 2148db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21499802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // TODO: Allow anything we can constant fold to an integer or fp constant. 21509802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) || 21519802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner isa<FloatingLiteral>(E)) 21529802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2153db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21549802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // Non-volatile automatic variables too, to get "cond ? X : Y" where 21559802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // X and Y are local variables. 21569802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 21579802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 2158df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (VD->hasLocalStorage() && !(CGF.getContext() 2159df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .getCanonicalType(VD->getType()) 2160df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .isVolatileQualified())) 21619802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2162db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21639802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return false; 21649802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner} 21659802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 21669802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 21677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter:: 21687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerVisitConditionalOperator(const ConditionalOperator *E) { 21697f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 217031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the condition constant folds and can be elided, try to avoid emitting 217131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the condition and the dead arm. 217231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getCond())){ 2173c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner Expr *Live = E->getLHS(), *Dead = E->getRHS(); 217431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (Cond == -1) 2175c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner std::swap(Live, Dead); 2176db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 217731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the dead side doesn't have labels we need, and if the Live side isn't 217831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the gnu missing ?: extension (which we could handle, but don't bother 217931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // to), just emit the Live part. 218031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if ((!Dead || !CGF.ContainsLabel(Dead)) && // No labels in dead part 218131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Live) // Live part isn't missing. 218231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return Visit(Live); 2183c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner } 2184db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21856155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // OpenCL: If the condition is a vector, we can treat this condition like 21866155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // the select function. 21876155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (CGF.getContext().getLangOptions().OpenCL 21886155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman && E->getCond()->getType()->isVectorType()) { 21896155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *CondV = CGF.EmitScalarExpr(E->getCond()); 21906155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *LHS = Visit(E->getLHS()); 21916155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *RHS = Visit(E->getRHS()); 21926155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 21936155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::Type *condType = ConvertType(E->getCond()->getType()); 21946155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::VectorType *vecTy = cast<llvm::VectorType>(condType); 21956155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 21966155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman unsigned numElem = vecTy->getNumElements(); 21976155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::Type *elemType = vecTy->getElementType(); 21986155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 21996155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman std::vector<llvm::Constant*> Zvals; 22006155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman for (unsigned i = 0; i < numElem; ++i) 22016155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman Zvals.push_back(llvm::ConstantInt::get(elemType,0)); 22026155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 22036155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *zeroVec = llvm::ConstantVector::get(Zvals); 22046155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec); 22056155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp = Builder.CreateSExt(TestMSB, 22066155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::VectorType::get(elemType, 22076155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman numElem), 22086155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman "sext"); 22096155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp2 = Builder.CreateNot(tmp); 22106155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 22116155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // Cast float to int to perform ANDs if necessary. 22126155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *RHSTmp = RHS; 22136155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *LHSTmp = LHS; 22146155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman bool wasCast = false; 22156155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType()); 22166155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (rhsVTy->getElementType()->isFloatTy()) { 22176155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType()); 22186155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman LHSTmp = Builder.CreateBitCast(LHS, tmp->getType()); 22196155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman wasCast = true; 22206155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 22216155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 22226155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2); 22236155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp); 22246155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond"); 22256155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (wasCast) 22266155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman tmp5 = Builder.CreateBitCast(tmp5, RHS->getType()); 2227db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22286155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman return tmp5; 22296155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 22306155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 22319802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // If this is a really simple expression (like x ? 4 : 5), emit this as a 22329802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // select instead of as control flow. We can only do this if it is cheap and 2233531a550531c144a58438f187816abbf1879e1c4eChris Lattner // safe to evaluate the LHS and RHS unconditionally. 2234df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (E->getLHS() && isCheapEnoughToEvaluateUnconditionally(E->getLHS(), 2235df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CGF) && 2236df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump isCheapEnoughToEvaluateUnconditionally(E->getRHS(), CGF)) { 22379802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *CondV = CGF.EvaluateExprAsBool(E->getCond()); 22389802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *LHS = Visit(E->getLHS()); 22399802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *RHS = Visit(E->getRHS()); 22409802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 22419802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner } 2242db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2243be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 2244be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 22459615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 2246af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian 2247db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If we don't have the GNU missing condition extension, emit a branch on bool 2248db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // the normal way. 224912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner if (E->getLHS()) { 225012d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for 225112d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the branch on bool. 225212d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 225312d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner } else { 225412d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, for the ?: extension, evaluate the conditional and then 225512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // convert it to bool the hard way. We do this explicitly because we need 225612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the unconverted value for the missing middle value of the ?:. 2257af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Expr *save = E->getSAVE(); 2258af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian assert(save && "VisitConditionalOperator - save is null"); 2259af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian // Intentianlly not doing direct assignment to ConditionalSaveExprs[save] !! 2260af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *SaveVal = CGF.EmitScalarExpr(save); 2261af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian CGF.ConditionalSaveExprs[save] = SaveVal; 2262af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *CondVal = Visit(E->getCond()); 226312d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // In some cases, EmitScalarConversion will delete the "CondVal" expression 226412d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // if there are no extra uses (an optimization). Inhibit this by making an 226512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // extra dead use, because we're going to add a use of CondVal later. We 226612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // don't use the builder for this, because we don't want it to get optimized 226712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // away. This leaves dead code, but the ?: extension isn't common. 226812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner new llvm::BitCastInst(CondVal, CondVal->getType(), "dummy?:holder", 226912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner Builder.GetInsertBlock()); 2270db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2271035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Value *CondBoolVal = 2272035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.EmitScalarConversion(CondVal, E->getCond()->getType(), 2273035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.getContext().BoolTy); 2274035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock); 2275035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner } 2276fb6fa30a9b06670deb14f862dddbc49a12552939Anders Carlsson 227772119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 22787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(LHSBlock); 2279db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the GNU extension for missing LHS. 2281af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *LHS = Visit(E->getTrueExpr()); 2282db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 228372119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 22847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHSBlock = Builder.GetInsertBlock(); 2285d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 2286db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 228772119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 22887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 2289db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2290856226c37ff10955c7f3f07ce6fa9522da23a3a5Eli Friedman Value *RHS = Visit(E->getRHS()); 229172119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 22927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2293d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 2294db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 2296db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 229748daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman // If the LHS or RHS is a throw expression, it will be legitimately null. 229848daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!LHS) 229948daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return RHS; 230048daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!RHS) 230148daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return LHS; 2302db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Create a PHI node for the real part. 23047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond"); 23057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->reserveOperandSpace(2); 23067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(LHS, LHSBlock); 23077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHS, RHSBlock); 23087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return PN; 23097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 23127976932a1c256d447316ffac58e9821417725e34Eli Friedman return Visit(E->getChosenSubExpr(CGF.getContext())); 23137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23152202bce80fc72d067cbe67dc1512f7b45351fd31Chris LattnerValue *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 23164fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 2317ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 2318ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 2319ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson // If EmitVAArg fails, we fall back to the LLVM instruction. 2320db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (!ArgPtr) 2321ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 2322ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 23237f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // FIXME Volatility. 2324ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateLoad(ArgPtr); 23257c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson} 23267c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 2327df6b68c9487aed2042c7fc23db10a79f89083a11Mike StumpValue *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *BE) { 23280892099dbc640720400a1d9decd2733a09d733e5Mike Stump return CGF.BuildBlockLiteralTmp(BE); 2329df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump} 2330df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 23317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 23327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Entry Point into this File 23337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 23347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2335db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitScalarExpr - Emit the computation of the specified expression of scalar 2336db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type, ignoring the result. 23377f79f9be5916c51c35da4f126b7c12596a101607Mike StumpValue *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 23387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E && !hasAggregateLLVMType(E->getType()) && 23397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Invalid scalar expression to emit"); 2340db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23417f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return ScalarExprEmitter(*this, IgnoreResultAssign) 23427f79f9be5916c51c35da4f126b7c12596a101607Mike Stump .Visit(const_cast<Expr*>(E)); 23437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23443707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 23453707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 23463707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 23474f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 23484f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 23493707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 23503707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner "Invalid scalar expression to emit"); 23513707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 23523707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 23534f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 2354db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 2355db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 2356db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 23574f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 23584f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, 23594f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 23609b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 23614f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner "Invalid complex -> scalar conversion"); 23624f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 23634f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner DstTy); 23644f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 2365cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 23668c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 23678c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *CodeGenFunction:: 23688c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 23698c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 23708c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre); 23718c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 23728c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2373820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz JahanianLValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 2374820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian llvm::Value *V; 2375820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // object->isa or (*object).isa 2376820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // Generate code as for: *(Class*)object 23775ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian // build Class* type 23785ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian const llvm::Type *ClassPtrTy = ConvertType(E->getType()); 23795ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian 2380820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Expr *BaseExpr = E->getBase(); 23815ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian if (BaseExpr->isLvalue(getContext()) != Expr::LV_Valid) { 23825ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = CreateTempAlloca(ClassPtrTy, "resval"); 23835ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian llvm::Value *Src = EmitScalarExpr(BaseExpr); 23845ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian Builder.CreateStore(Src, V); 23859f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue( 23869f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar MakeAddrLValue(V, E->getType()), E->getType()); 23879f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar } else { 23889f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar if (E->isArrow()) 23899f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr); 23909f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar else 23919f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = EmitLValue(BaseExpr).getAddress(); 23925ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 2393820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 2394820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // build Class* type 2395820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian ClassPtrTy = ClassPtrTy->getPointerTo(); 2396820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian V = Builder.CreateBitCast(V, ClassPtrTy); 23979f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(V, E->getType()); 2398820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian} 2399820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 24006a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 24016a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue CodeGenFunction::EmitCompoundAssignOperatorLValue( 24026a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E) { 24036a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor ScalarExprEmitter Scalar(*this); 2404d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *Result = 0; 24056a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor switch (E->getOpcode()) { 24066a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#define COMPOUND_OP(Op) \ 24072de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_##Op##Assign: \ 24086a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 2409d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result) 24106a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Mul); 24116a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Div); 24126a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Rem); 24136a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Add); 24146a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Sub); 24156a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shl); 24166a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shr); 24176a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(And); 24186a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Xor); 24196a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Or); 24206a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#undef COMPOUND_OP 24216a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 24222de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemD: 24232de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemI: 24242de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 24252de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Div: 24262de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Rem: 24272de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 24282de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 24292de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shl: 24302de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shr: 24312de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LT: 24322de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GT: 24332de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LE: 24342de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GE: 24352de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_EQ: 24362de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_NE: 24372de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_And: 24382de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Xor: 24392de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Or: 24402de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LAnd: 24412de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LOr: 24422de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Assign: 24432de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Comma: 24446a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor assert(false && "Not valid compound assignment operators"); 24456a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor break; 24466a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor } 24476a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 24486a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor llvm_unreachable("Unhandled compound assignment operator"); 24496a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 2450