CGExprScalar.cpp revision 7cabee5b18212bd3106aea8415b044b2b3b43518
17f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===// 27f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 37f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// The LLVM Compiler Infrastructure 47f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 77f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 87f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 97f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// This contains code to emit Expr nodes with scalar LLVM types as LLVM code. 117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "CodeGenFunction.h" 157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "CodeGenModule.h" 16de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 1798c5ead87d720d8b68b6f236c3c3579a388fc882Daniel Dunbar#include "clang/AST/DeclObjC.h" 18769e411b72465a63454cdd416ff26ff313d43505Eli Friedman#include "clang/AST/RecordLayout.h" 19de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/StmtVisitor.h" 2025ddea7f7835c4b1804e458a5c866cde0097430aChris Lattner#include "clang/Basic/TargetInfo.h" 217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "llvm/Constants.h" 227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "llvm/Function.h" 2385f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson#include "llvm/GlobalVariable.h" 247c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson#include "llvm/Intrinsics.h" 252add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump#include "llvm/Module.h" 267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "llvm/Support/Compiler.h" 27f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner#include "llvm/Support/CFG.h" 284e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump#include "llvm/Target/TargetData.h" 29c89bf69c9289d2b2305f2c267daacc7312391898Chris Lattner#include <cstdarg> 306aad91a43e26118c824d976661077819265d9bc0Ted Kremenek 317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing namespace clang; 327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing namespace CodeGen; 337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing llvm::Value; 347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Scalar Expression Emitter 377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerstruct BinOpInfo { 407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS; 417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS; 421f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner QualType Ty; // Computation Type. 437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner const BinaryOperator *E; 447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnernamespace { 477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerclass VISIBILITY_HIDDEN ScalarExprEmitter 487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner : public StmtVisitor<ScalarExprEmitter, Value*> { 497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction &CGF; 5045d196b8387dcefc4df26cda114fa34c6528e928Daniel Dunbar CGBuilderTy &Builder; 512b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner 527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerpublic: 537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 542b94fe35edf951a14ecd32b21f7ebcc2e3754c67Chris Lattner ScalarExprEmitter(CodeGenFunction &cgf) : CGF(cgf), 55ed7c618f849e2541b1d0288c43154937652c5b15Daniel Dunbar Builder(CGF.Builder) { 567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Utilities 607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); } 637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); } 647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(LValue LV, QualType T) { 669b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitLoadOfLValue(LV, T).getScalarVal(); 677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// EmitLoadOfLValue - Given an expression with complex type that represents a 707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// value l-value, this method emits the address of the l-value, then loads 717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// and returns the result. 727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(const Expr *E) { 737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(EmitLValue(E), E->getType()); 747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 769abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner /// EmitConversionToBool - Convert the specified expression value to a 773420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner /// boolean (i1) truth value. This is equivalent to "Val != 0". 789abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner Value *EmitConversionToBool(Value *Src, QualType DstTy); 799abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 803707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// EmitScalarConversion - Emit a conversion from the specified type to the 813707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// specified destination type, both of which are LLVM scalar types. 824f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy); 834f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 844f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner /// EmitComplexToScalarConversion - Emit a conversion from the specified 854f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner /// complex type to the specified destination type, where the destination 864f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner /// type is an LLVM scalar type. 874f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 884f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy); 89df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Visitor Methods 927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitStmt(Stmt *S) { 957a9d49fd2bfac00e905b361ba76d26ab5b6c3b09Ted Kremenek S->dump(CGF.getContext().getSourceManager()); 967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(0 && "Stmt can't have complex result type!"); 977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitExpr(Expr *S); 1007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr()); } 1017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Leaves. 1037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitIntegerLiteral(const IntegerLiteral *E) { 1047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return llvm::ConstantInt::get(E->getValue()); 1057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitFloatingLiteral(const FloatingLiteral *E) { 10759138ba7ce960888433546639deb45e2e03f8857Chris Lattner return llvm::ConstantFP::get(E->getValue()); 1087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCharacterLiteral(const CharacterLiteral *E) { 1107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 111e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman } 112e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 113e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 1147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1157267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis Value *VisitCXXZeroInitValueExpr(const CXXZeroInitValueExpr *E) { 1167267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis return llvm::Constant::getNullValue(ConvertType(E->getType())); 1177267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis } 1183f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson Value *VisitGNUNullExpr(const GNUNullExpr *E) { 1193f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson return llvm::Constant::getNullValue(ConvertType(E->getType())); 1203f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson } 1217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) { 1227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return llvm::ConstantInt::get(ConvertType(E->getType()), 123ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff CGF.getContext().typesAreCompatible( 124ec0550fa3653d46560bf4484a2e988329c228e39Steve Naroff E->getArgType1(), E->getArgType2())); 1257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1260518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl Value *VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E); 1270ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar Value *VisitAddrLabelExpr(const AddrLabelExpr *E) { 12854d19091a809d30a5e6e352fda53377d69ebda66Daniel Dunbar llvm::Value *V = 12954d19091a809d30a5e6e352fda53377d69ebda66Daniel Dunbar llvm::ConstantInt::get(llvm::Type::Int32Ty, 13054d19091a809d30a5e6e352fda53377d69ebda66Daniel Dunbar CGF.GetIDForAddrOfLabel(E->getLabel())); 13154d19091a809d30a5e6e352fda53377d69ebda66Daniel Dunbar 13254d19091a809d30a5e6e352fda53377d69ebda66Daniel Dunbar return Builder.CreateIntToPtr(V, ConvertType(E->getType())); 1330ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar } 1347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // l-values. 1367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitDeclRefExpr(DeclRefExpr *E) { 1377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(E->getDecl())) 1387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return llvm::ConstantInt::get(EC->getInitVal()); 1397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 1407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1419c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 1429c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return CGF.EmitObjCSelectorExpr(E); 1439c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 1449c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 1459c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return CGF.EmitObjCProtocolExpr(E); 1469c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 1479c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 1489c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return EmitLoadOfLValue(E); 1499c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 1500a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 15185c59edda02df48fae8dc85049743319bc6e7e89Daniel Dunbar return EmitLoadOfLValue(E); 1529c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 15343f447098d5e6162fbfb97ed38365284207a7fbeFariborz Jahanian Value *VisitObjCKVCRefExpr(ObjCKVCRefExpr *E) { 15443f447098d5e6162fbfb97ed38365284207a7fbeFariborz Jahanian return EmitLoadOfLValue(E); 15543f447098d5e6162fbfb97ed38365284207a7fbeFariborz Jahanian } 1569c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar Value *VisitObjCMessageExpr(ObjCMessageExpr *E) { 1579c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return CGF.EmitObjCMessageExpr(E).getScalarVal(); 1580a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar } 1590a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar 1607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 161d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E); 1627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitMemberExpr(Expr *E) { return EmitLoadOfLValue(E); } 163213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); } 164be20bb558cae5352898e6a913e29d24d20134841Chris Lattner Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 165be20bb558cae5352898e6a913e29d24d20134841Chris Lattner return EmitLoadOfLValue(E); 166be20bb558cae5352898e6a913e29d24d20134841Chris Lattner } 1677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitStringLiteral(Expr *E) { return EmitLValue(E).getAddress(); } 168eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner Value *VisitObjCEncodeExpr(const ObjCEncodeExpr *E) { 169eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner return EmitLValue(E).getAddress(); 170eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner } 171eaf2bb89eb2aad3b80673de30febe52df43c10ecChris Lattner 172d9f6910f4ef37c0e8eeee2a01287d9572c3176efChris Lattner Value *VisitPredefinedExpr(Expr *E) { return EmitLValue(E).getAddress(); } 17335634f5ed67966c9f1fde38420e79cc6515cd673Devang Patel 17435634f5ed67966c9f1fde38420e79cc6515cd673Devang Patel Value *VisitInitListExpr(InitListExpr *E) { 1757019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson unsigned NumInitElements = E->getNumInits(); 1767019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson 177a9c878086036de36482cc21e35a33cabe9699b0aDouglas Gregor if (E->hadArrayRangeDesignator()) { 178a9c878086036de36482cc21e35a33cabe9699b0aDouglas Gregor CGF.ErrorUnsupported(E, "GNU array range designator extension"); 179a9c878086036de36482cc21e35a33cabe9699b0aDouglas Gregor } 180a9c878086036de36482cc21e35a33cabe9699b0aDouglas Gregor 1817019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson const llvm::VectorType *VType = 182f6884ac7cfc4c5562c0678ad65b3460a38f56e23Anders Carlsson dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 183f6884ac7cfc4c5562c0678ad65b3460a38f56e23Anders Carlsson 184f6884ac7cfc4c5562c0678ad65b3460a38f56e23Anders Carlsson // We have a scalar in braces. Just use the first element. 185f6884ac7cfc4c5562c0678ad65b3460a38f56e23Anders Carlsson if (!VType) 186f6884ac7cfc4c5562c0678ad65b3460a38f56e23Anders Carlsson return Visit(E->getInit(0)); 1877019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson 1887019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson unsigned NumVectorElements = VType->getNumElements(); 1897019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson const llvm::Type *ElementType = VType->getElementType(); 1907019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson 1917019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson // Emit individual vector element stores. 1927019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson llvm::Value *V = llvm::UndefValue::get(VType); 1937019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson 194222d2c8b7886e37ba22f0b25ac7a6552f7cc8492Anders Carlsson // Emit initializers 195222d2c8b7886e37ba22f0b25ac7a6552f7cc8492Anders Carlsson unsigned i; 196222d2c8b7886e37ba22f0b25ac7a6552f7cc8492Anders Carlsson for (i = 0; i < NumInitElements; ++i) { 197a83cc33195c7d1fa31d6809416eaa4c3ebf036ebDevang Patel Value *NewV = Visit(E->getInit(i)); 198a83cc33195c7d1fa31d6809416eaa4c3ebf036ebDevang Patel Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i); 199a83cc33195c7d1fa31d6809416eaa4c3ebf036ebDevang Patel V = Builder.CreateInsertElement(V, NewV, Idx); 20035634f5ed67966c9f1fde38420e79cc6515cd673Devang Patel } 2017019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson 2027019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson // Emit remaining default initializers 2037019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson for (/* Do not initialize i*/; i < NumVectorElements; ++i) { 2047019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i); 2057019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson llvm::Value *NewV = llvm::Constant::getNullValue(ElementType); 2067019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson V = Builder.CreateInsertElement(V, NewV, Idx); 2077019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson } 2087019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson 209a83cc33195c7d1fa31d6809416eaa4c3ebf036ebDevang Patel return V; 21035634f5ed67966c9f1fde38420e79cc6515cd673Devang Patel } 21104421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner 2123498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) { 2133498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return llvm::Constant::getNullValue(ConvertType(E->getType())); 2143498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor } 2157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitImplicitCastExpr(const ImplicitCastExpr *E); 216c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman Value *VisitCastExpr(const CastExpr *E) { 217c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman // Make sure to evaluate VLA bounds now so that we have them for later. 218c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman if (E->getType()->isVariablyModifiedType()) 219c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman CGF.EmitVLASize(E->getType()); 220c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman 2217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitCastExpr(E->getSubExpr(), E->getType()); 2227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitCastExpr(const Expr *E, QualType T); 2247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCallExpr(const CallExpr *E) { 2269b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitCallExpr(E).getScalarVal(); 2277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2288f2926b73ed635afecd020da787af6a837601a2bDaniel Dunbar 2293379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner Value *VisitStmtExpr(const StmtExpr *E); 2304e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump 231a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike Stump Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E); 2323379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 2337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Unary Operators. 2347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitPrePostIncDec(const UnaryOperator *E, bool isInc, bool isPre); 2357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostDec(const UnaryOperator *E) { 2367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return VisitPrePostIncDec(E, false, false); 2377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostInc(const UnaryOperator *E) { 2397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return VisitPrePostIncDec(E, true, false); 2407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreDec(const UnaryOperator *E) { 2427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return VisitPrePostIncDec(E, false, true); 2437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreInc(const UnaryOperator *E) { 2457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return VisitPrePostIncDec(E, true, true); 2467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryAddrOf(const UnaryOperator *E) { 2487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLValue(E->getSubExpr()).getAddress(); 2497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 2517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPlus(const UnaryOperator *E) { 2527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 2537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryMinus (const UnaryOperator *E); 2557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryNot (const UnaryOperator *E); 2567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryLNot (const UnaryOperator *E); 25746f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryReal (const UnaryOperator *E); 25846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryImag (const UnaryOperator *E); 2597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryExtension(const UnaryOperator *E) { 2607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 2617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2625a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson Value *VisitUnaryOffsetOf(const UnaryOperator *E); 2635f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson 2645f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson // C++ 26504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 26604421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 26704421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 2685f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson Value *VisitCXXThisExpr(CXXThisExpr *TE) { 2695f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson return CGF.LoadCXXThis(); 2705f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson } 2715a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson 2727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Binary Operators. 2737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitMul(const BinOpInfo &Ops) { 274035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump if (CGF.getContext().getLangOptions().OverflowChecking 275035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump && Ops.Ty->isSignedIntegerType()) 2762add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump return EmitOverflowCheckedBinOp(Ops); 2777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 2787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2792add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Create a binary op that checks for overflow. 2802add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Currently only supports +, - and *. 2812add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); 2827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitDiv(const BinOpInfo &Ops); 2837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitRem(const BinOpInfo &Ops); 2847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAdd(const BinOpInfo &Ops); 2857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitSub(const BinOpInfo &Ops); 2867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShl(const BinOpInfo &Ops); 2877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShr(const BinOpInfo &Ops); 2887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAnd(const BinOpInfo &Ops) { 2897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 2907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitXor(const BinOpInfo &Ops) { 2927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 2937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitOr (const BinOpInfo &Ops) { 2957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 2967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2981f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo EmitBinOps(const BinaryOperator *E); 2993ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *EmitCompoundAssign(const CompoundAssignOperator *E, 3001f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 3011f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 3021f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Binary operators and binary compound assignment operators. 3031f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#define HANDLEBINOP(OP) \ 3043ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP(const BinaryOperator *E) { \ 3053ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return Emit ## OP(EmitBinOps(E)); \ 3063ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner } \ 3073ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 3083ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 3091f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 3101f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner HANDLEBINOP(Mul); 3111f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner HANDLEBINOP(Div); 3121f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner HANDLEBINOP(Rem); 3131f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner HANDLEBINOP(Add); 3148c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar HANDLEBINOP(Sub); 3151f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner HANDLEBINOP(Shl); 3161f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner HANDLEBINOP(Shr); 3171f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner HANDLEBINOP(And); 3181f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner HANDLEBINOP(Xor); 3191f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner HANDLEBINOP(Or); 3201f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#undef HANDLEBINOP 3218c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 3227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Comparisons. 3237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 3247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc); 3257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#define VISITCOMP(CODE, UI, SI, FP) \ 3267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBin##CODE(const BinaryOperator *E) { \ 3277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 3287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::FCmpInst::FP); } 3297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT); 3307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT); 3317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE); 3327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE); 3337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ); 3347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE); 3357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#undef VISITCOMP 3367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinAssign (const BinaryOperator *E); 3387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLAnd (const BinaryOperator *E); 3407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLOr (const BinaryOperator *E); 3417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinComma (const BinaryOperator *E); 3427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Other Operators. 344df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump Value *VisitBlockExpr(const BlockExpr *BE); 3457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitConditionalOperator(const ConditionalOperator *CO); 3467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitChooseExpr(ChooseExpr *CE); 3477c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson Value *VisitVAArgExpr(VAArgExpr *VE); 3487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 3497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return CGF.EmitObjCStringLiteral(E); 3507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 3527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} // end anonymous namespace. 3537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 3557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Utilities 3567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 3577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 3589abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner/// EmitConversionToBool - Convert the specified expression value to a 3593420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner/// boolean (i1) truth value. This is equivalent to "Val != 0". 3609abc84e7ac4db891209fe67cc3a8c9690dc886efChris LattnerValue *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 3619abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner assert(SrcType->isCanonical() && "EmitScalarConversion strips typedefs"); 3629abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 3639abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner if (SrcType->isRealFloatingType()) { 3649abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Compare against 0.0 for fp scalars. 3659abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 3669abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Builder.CreateFCmpUNE(Src, Zero, "tobool"); 3679abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 3689abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 369d1d66bcd6914ff82abdfa88dd25bb0b74cde3b99Daniel Dunbar assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 3709abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner "Unknown scalar type to convert"); 3719abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 3729abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Because of the type rules of C, we often end up computing a logical value, 3739abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // then zero extending it to int, then wanting it as a logical value again. 3749abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Optimize this common case. 3759abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(Src)) { 3769abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner if (ZI->getOperand(0)->getType() == llvm::Type::Int1Ty) { 3779abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner Value *Result = ZI->getOperand(0); 378356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // If there aren't any more uses, zap the instruction to save space. 379356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // Note that there can be more uses, for example if this 380356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman // is the result of an assignment. 381356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman if (ZI->use_empty()) 382356916ec84826a793b0353e5db0e9a7589b9ec5cEli Friedman ZI->eraseFromParent(); 3839abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Result; 3849abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 3859abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner } 3869abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 3879abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner // Compare against an integer or pointer null. 3889abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType()); 3899abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner return Builder.CreateICmpNE(Src, Zero, "tobool"); 3909abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner} 3919abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 3923707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 3933707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 3944f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 3954f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstType) { 3969619662a1d42e2008b865d3459c0677e149dad1bChris Lattner SrcType = CGF.getContext().getCanonicalType(SrcType); 3979619662a1d42e2008b865d3459c0677e149dad1bChris Lattner DstType = CGF.getContext().getCanonicalType(DstType); 3983707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (SrcType == DstType) return Src; 399cf289083ab007264fa3ea96d92f133339aee5d2dChris Lattner 400cf289083ab007264fa3ea96d92f133339aee5d2dChris Lattner if (DstType->isVoidType()) return 0; 4013707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4023707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 403ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstType->isBooleanType()) 404ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return EmitConversionToBool(Src, SrcType); 4053707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4063707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner const llvm::Type *DstTy = ConvertType(DstType); 4073707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4083707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Ignore conversions like int -> uint. 4093707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (Src->getType() == DstTy) 4103707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Src; 4113707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 412270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar // Handle pointer conversions next: pointers can only be converted 413270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar // to/from other pointers and integers. Check for pointer types in 414270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar // terms of LLVM, as some native types (like Obj-C id) may map to a 415270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar // pointer type. 416270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(DstTy)) { 4173707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // The source value may be an integer, or a pointer. 4183707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::PointerType>(Src->getType())) 4193707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Builder.CreateBitCast(Src, DstTy, "conv"); 4203707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 42125615424741bcce31fe52c896f76268f0307f00dEli Friedman // First, convert to the correct width so that we control the kind of 42225615424741bcce31fe52c896f76268f0307f00dEli Friedman // extension. 42325615424741bcce31fe52c896f76268f0307f00dEli Friedman const llvm::Type *MiddleTy = llvm::IntegerType::get(CGF.LLVMPointerWidth); 42425615424741bcce31fe52c896f76268f0307f00dEli Friedman bool InputSigned = SrcType->isSignedIntegerType(); 42525615424741bcce31fe52c896f76268f0307f00dEli Friedman llvm::Value* IntResult = 42625615424741bcce31fe52c896f76268f0307f00dEli Friedman Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 42725615424741bcce31fe52c896f76268f0307f00dEli Friedman // Then, cast to pointer. 42825615424741bcce31fe52c896f76268f0307f00dEli Friedman return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 4293707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 4303707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 431270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(Src->getType())) { 4323707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Must be an ptr to int cast. 4333707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 43450b5a30db40322880340e957ad7d6d8d60bb4c5bAnders Carlsson return Builder.CreatePtrToInt(Src, DstTy, "conv"); 4353707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 4363707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 437213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // A scalar can be splatted to an extended vector of the same element type 4386fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman if (DstType->isExtVectorType() && !isa<VectorType>(SrcType)) { 4396fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Cast the scalar to element type 4406fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman QualType EltTy = DstType->getAsExtVectorType()->getElementType(); 4416fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 4426fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 4436fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Insert the element in element zero of an undef vector 4446fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *UnV = llvm::UndefValue::get(DstTy); 4456fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0); 4466fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 4476fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 4486fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Splat the element across to all elements 4496fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 4506fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 4516fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman for (unsigned i = 0; i < NumElements; i++) 4526fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, 0)); 4536fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 4546fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 4556fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 4566fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman return Yay; 4576fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman } 4584119d1aeca8016654d381ce079864058d1709571Nate Begeman 4593b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner // Allow bitcast from vector to integer/fp of the same size. 4607019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson if (isa<llvm::VectorType>(Src->getType()) || 4613b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner isa<llvm::VectorType>(DstTy)) 4627019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson return Builder.CreateBitCast(Src, DstTy, "conv"); 4637019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson 4643707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Finally, we have the arithmetic types: real int/float. 4653707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(Src->getType())) { 4663707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner bool InputSigned = SrcType->isSignedIntegerType(); 467b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (isa<llvm::IntegerType>(DstTy)) 468b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 469b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else if (InputSigned) 470b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateSIToFP(Src, DstTy, "conv"); 471b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 472b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateUIToFP(Src, DstTy, "conv"); 4733707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 4743707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4753707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(Src->getType()->isFloatingPoint() && "Unknown real conversion"); 4763707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(DstTy)) { 477b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstType->isSignedIntegerType()) 478b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToSI(Src, DstTy, "conv"); 479b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 480b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToUI(Src, DstTy, "conv"); 4813707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 4823707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4833707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(DstTy->isFloatingPoint() && "Unknown real conversion"); 484b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstTy->getTypeID() < Src->getType()->getTypeID()) 485b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPTrunc(Src, DstTy, "conv"); 486b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 487b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPExt(Src, DstTy, "conv"); 4883707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 4893707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 4904f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner/// EmitComplexToScalarConversion - Emit a conversion from the specified 4914f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner/// complex type to the specified destination type, where the destination 4924f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner/// type is an LLVM scalar type. 4934f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter:: 4944f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerEmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 4954f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy) { 496ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Get the source element type. 4979619662a1d42e2008b865d3459c0677e149dad1bChris Lattner SrcTy = SrcTy->getAsComplexType()->getElementType(); 498ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner 499ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 500ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstTy->isBooleanType()) { 501ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Complex != 0 -> (Real != 0) | (Imag != 0) 502ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 503ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 504ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return Builder.CreateOr(Src.first, Src.second, "tobool"); 505ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner } 506ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner 5074f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 5084f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // the imaginary part of the complex value is discarded and the value of the 5094f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // real part is converted according to the conversion rules for the 5104f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // corresponding real type. 5114f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return EmitScalarConversion(Src.first, SrcTy, DstTy); 5124f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 5134f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 5144f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 5157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Visitor Methods 5177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitExpr(Expr *E) { 520488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGF.ErrorUnsupported(E, "scalar expression"); 5217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getType()->isVoidType()) 5227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 5237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 5247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 5257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 526d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanValue *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 527d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman llvm::SmallVector<llvm::Constant*, 32> indices; 528d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 529d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman indices.push_back(cast<llvm::Constant>(CGF.EmitScalarExpr(E->getExpr(i)))); 530d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 531d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 532d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 533d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* SV = llvm::ConstantVector::get(indices.begin(), indices.size()); 534d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 535d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 536d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 5377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 5387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Emit subscript expressions in rvalue context's. For most cases, this just 5397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // loads the lvalue formed by the subscript expr. However, we have to be 5407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // careful, because the base of a vector subscript is occasionally an rvalue, 5417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // so we can't get it as an lvalue. 5427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (!E->getBase()->getType()->isVectorType()) 5437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 5447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the vector case. The base must be a vector, the index must be an 5467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // integer value. 5477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Base = Visit(E->getBase()); 5487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Idx = Visit(E->getIdx()); 549daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman bool IdxSigned = E->getIdx()->getType()->isSignedIntegerType(); 550515ff5a31d75df9f4f099458a31cd7a405cf513dEli Friedman Idx = Builder.CreateIntCast(Idx, llvm::Type::Int32Ty, IdxSigned, 551515ff5a31d75df9f4f099458a31cd7a405cf513dEli Friedman "vecidxcast"); 5527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateExtractElement(Base, Idx, "vecext"); 5537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 5547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner/// VisitImplicitCastExpr - Implicit casts are the same as normal casts, but 5567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner/// also handle things like function to pointer-to-function decay, and array to 5577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner/// pointer decay. 5587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitImplicitCastExpr(const ImplicitCastExpr *E) { 5597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner const Expr *Op = E->getSubExpr(); 5607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // If this is due to array->pointer conversion, emit the array expression as 5627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // an l-value. 5637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Op->getType()->isArrayType()) { 5644f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *V = EmitLValue(Op).getAddress(); // Bitfields can't be arrays. 5658f39f5e96ce4a5f401f431f61db7df1cf05dce6fEli Friedman 566daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // Note that VLA pointers are always decayed, so we don't need to do 567daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // anything here. 5688f39f5e96ce4a5f401f431f61db7df1cf05dce6fEli Friedman if (!Op->getType()->isVariableArrayType()) { 5698f39f5e96ce4a5f401f431f61db7df1cf05dce6fEli Friedman assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 5708f39f5e96ce4a5f401f431f61db7df1cf05dce6fEli Friedman assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 5718f39f5e96ce4a5f401f431f61db7df1cf05dce6fEli Friedman ->getElementType()) && 5728f39f5e96ce4a5f401f431f61db7df1cf05dce6fEli Friedman "Expected pointer to array"); 5738f39f5e96ce4a5f401f431f61db7df1cf05dce6fEli Friedman V = Builder.CreateStructGEP(V, 0, "arraydecay"); 574662174c82ef46b19a2329c7d37208e1d12dfb7b3Daniel Dunbar } 575a9e6372208ad77eb2cae639a8a17c86551ac1937Chris Lattner 576a9e6372208ad77eb2cae639a8a17c86551ac1937Chris Lattner // The resultant pointer type can be implicitly casted to other pointer 577f31627f676374812d0355d7e34fd2e940b400757Chris Lattner // types as well (e.g. void*) and can be implicitly converted to integer. 578f31627f676374812d0355d7e34fd2e940b400757Chris Lattner const llvm::Type *DestTy = ConvertType(E->getType()); 579f31627f676374812d0355d7e34fd2e940b400757Chris Lattner if (V->getType() != DestTy) { 580f31627f676374812d0355d7e34fd2e940b400757Chris Lattner if (isa<llvm::PointerType>(DestTy)) 581f31627f676374812d0355d7e34fd2e940b400757Chris Lattner V = Builder.CreateBitCast(V, DestTy, "ptrconv"); 582f31627f676374812d0355d7e34fd2e940b400757Chris Lattner else { 583f31627f676374812d0355d7e34fd2e940b400757Chris Lattner assert(isa<llvm::IntegerType>(DestTy) && "Unknown array decay"); 584f31627f676374812d0355d7e34fd2e940b400757Chris Lattner V = Builder.CreatePtrToInt(V, DestTy, "ptrconv"); 585f31627f676374812d0355d7e34fd2e940b400757Chris Lattner } 586f31627f676374812d0355d7e34fd2e940b400757Chris Lattner } 587a9e6372208ad77eb2cae639a8a17c86551ac1937Chris Lattner return V; 5887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 589daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 5907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitCastExpr(Op, E->getType()); 5917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 5927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 5957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// have to handle a more broad range of conversions than explicit casts, as they 5967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// handle things like function to ptr-to-function decay etc. 5977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitCastExpr(const Expr *E, QualType DestTy) { 59858a2e944faa16f1f61439acd2e71b19f50189511Chris Lattner // Handle cases where the source is an non-complex type. 59919a1d7c646729eb858b15583e647262a22de3637Chris Lattner 60019a1d7c646729eb858b15583e647262a22de3637Chris Lattner if (!CGF.hasAggregateLLVMType(E->getType())) { 6013707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner Value *Src = Visit(const_cast<Expr*>(E)); 6023707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 6033707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Use EmitScalarConversion to perform the conversion. 6043707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return EmitScalarConversion(Src, E->getType(), DestTy); 6053707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 60619a1d7c646729eb858b15583e647262a22de3637Chris Lattner 6079b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (E->getType()->isAnyComplexType()) { 60819a1d7c646729eb858b15583e647262a22de3637Chris Lattner // Handle cases where the source is a complex type. 60919a1d7c646729eb858b15583e647262a22de3637Chris Lattner return EmitComplexToScalarConversion(CGF.EmitComplexExpr(E), E->getType(), 61019a1d7c646729eb858b15583e647262a22de3637Chris Lattner DestTy); 61119a1d7c646729eb858b15583e647262a22de3637Chris Lattner } 61210b00cfe6422906b223724048b9b2123968d3baaChris Lattner 61319a1d7c646729eb858b15583e647262a22de3637Chris Lattner // Okay, this is a cast from an aggregate. It must be a cast to void. Just 61419a1d7c646729eb858b15583e647262a22de3637Chris Lattner // evaluate the result and return. 61519a1d7c646729eb858b15583e647262a22de3637Chris Lattner CGF.EmitAggExpr(E, 0, false); 61619a1d7c646729eb858b15583e647262a22de3637Chris Lattner return 0; 6177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 6187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6193379320c10001d7e1ee5d7e7142c417f797cfe82Chris LattnerValue *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 62091d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner return CGF.EmitCompoundStmt(*E->getSubStmt(), 62191d723da7b68be5245c3ac58aa2a36d04658cfb8Chris Lattner !E->getType()->isVoidType()).getScalarVal(); 6223379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner} 6233379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 624a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike StumpValue *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 625a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike Stump return Builder.CreateLoad(CGF.GetAddrOfBlockDecl(E), false, "tmp"); 6264e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump} 6273379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 6287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Unary Operators 6307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitPrePostIncDec(const UnaryOperator *E, 633dfce2a51a78455c915722bc05f07c41e600220c9Chris Lattner bool isInc, bool isPre) { 6347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LValue LV = EmitLValue(E->getSubExpr()); 635f52bbeb1ce55aa10b4519024258b8962777fa8d4Eli Friedman QualType ValTy = E->getSubExpr()->getType(); 636f52bbeb1ce55aa10b4519024258b8962777fa8d4Eli Friedman Value *InVal = CGF.EmitLoadOfLValue(LV, ValTy).getScalarVal(); 6377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner int AmountVal = isInc ? 1 : -1; 639daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 640daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman if (ValTy->isPointerType() && 641daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman ValTy->getAsPointerType()->isVariableArrayType()) { 642daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition/subtraction needs to account for the VLA size 643daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman CGF.ErrorUnsupported(E, "VLA pointer inc/dec"); 644daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 645daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 6467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *NextVal; 6478cc9d08eb8b2652ca939d724ab64dec906e418a0Chris Lattner if (const llvm::PointerType *PT = 6488cc9d08eb8b2652ca939d724ab64dec906e418a0Chris Lattner dyn_cast<llvm::PointerType>(InVal->getType())) { 6498cc9d08eb8b2652ca939d724ab64dec906e418a0Chris Lattner llvm::Constant *Inc =llvm::ConstantInt::get(llvm::Type::Int32Ty, AmountVal); 6508cc9d08eb8b2652ca939d724ab64dec906e418a0Chris Lattner if (!isa<llvm::FunctionType>(PT->getElementType())) { 6518cc9d08eb8b2652ca939d724ab64dec906e418a0Chris Lattner NextVal = Builder.CreateGEP(InVal, Inc, "ptrincdec"); 6528cc9d08eb8b2652ca939d724ab64dec906e418a0Chris Lattner } else { 6538cc9d08eb8b2652ca939d724ab64dec906e418a0Chris Lattner const llvm::Type *i8Ty = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 6548cc9d08eb8b2652ca939d724ab64dec906e418a0Chris Lattner NextVal = Builder.CreateBitCast(InVal, i8Ty, "tmp"); 6558cc9d08eb8b2652ca939d724ab64dec906e418a0Chris Lattner NextVal = Builder.CreateGEP(NextVal, Inc, "ptrincdec"); 6568cc9d08eb8b2652ca939d724ab64dec906e418a0Chris Lattner NextVal = Builder.CreateBitCast(NextVal, InVal->getType()); 6578cc9d08eb8b2652ca939d724ab64dec906e418a0Chris Lattner } 658db3bd4b4eabc325781a6a407c3dcf68a8d6db0f9Chris Lattner } else if (InVal->getType() == llvm::Type::Int1Ty && isInc) { 659db3bd4b4eabc325781a6a407c3dcf68a8d6db0f9Chris Lattner // Bool++ is an interesting case, due to promotion rules, we get: 660db3bd4b4eabc325781a6a407c3dcf68a8d6db0f9Chris Lattner // Bool++ -> Bool = Bool+1 -> Bool = (int)Bool+1 -> 661db3bd4b4eabc325781a6a407c3dcf68a8d6db0f9Chris Lattner // Bool = ((int)Bool+1) != 0 662db3bd4b4eabc325781a6a407c3dcf68a8d6db0f9Chris Lattner // An interesting aspect of this is that increment is always true. 663db3bd4b4eabc325781a6a407c3dcf68a8d6db0f9Chris Lattner // Decrement does not have this property. 664db3bd4b4eabc325781a6a407c3dcf68a8d6db0f9Chris Lattner NextVal = llvm::ConstantInt::getTrue(); 665e936cc8890b94e83f530453c8c9167fb5de9b5faChris Lattner } else { 666e936cc8890b94e83f530453c8c9167fb5de9b5faChris Lattner // Add the inc/dec to the real part. 667e936cc8890b94e83f530453c8c9167fb5de9b5faChris Lattner if (isa<llvm::IntegerType>(InVal->getType())) 668e936cc8890b94e83f530453c8c9167fb5de9b5faChris Lattner NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal); 669ca2617c0e1f87c9da4d9aa3db4ea854ee2f6a1daChris Lattner else if (InVal->getType() == llvm::Type::FloatTy) 670e9b8c0a38549692f1b8f688c05c35442fc620865Devang Patel NextVal = 67159138ba7ce960888433546639deb45e2e03f8857Chris Lattner llvm::ConstantFP::get(llvm::APFloat(static_cast<float>(AmountVal))); 67225ddea7f7835c4b1804e458a5c866cde0097430aChris Lattner else if (InVal->getType() == llvm::Type::DoubleTy) 673e9b8c0a38549692f1b8f688c05c35442fc620865Devang Patel NextVal = 67459138ba7ce960888433546639deb45e2e03f8857Chris Lattner llvm::ConstantFP::get(llvm::APFloat(static_cast<double>(AmountVal))); 67525ddea7f7835c4b1804e458a5c866cde0097430aChris Lattner else { 67625ddea7f7835c4b1804e458a5c866cde0097430aChris Lattner llvm::APFloat F(static_cast<float>(AmountVal)); 677ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen bool ignored; 678ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 679ee5a700af3fe9ae1a639c271f093f40677dddc04Dale Johannesen &ignored); 68025ddea7f7835c4b1804e458a5c866cde0097430aChris Lattner NextVal = llvm::ConstantFP::get(F); 681ca2617c0e1f87c9da4d9aa3db4ea854ee2f6a1daChris Lattner } 682e936cc8890b94e83f530453c8c9167fb5de9b5faChris Lattner NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 683e936cc8890b94e83f530453c8c9167fb5de9b5faChris Lattner } 6847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Store the updated result through the lvalue. 686f52bbeb1ce55aa10b4519024258b8962777fa8d4Eli Friedman if (LV.isBitfield()) 687f52bbeb1ce55aa10b4519024258b8962777fa8d4Eli Friedman CGF.EmitStoreThroughBitfieldLValue(RValue::get(NextVal), LV, ValTy, 688f52bbeb1ce55aa10b4519024258b8962777fa8d4Eli Friedman &NextVal); 689f52bbeb1ce55aa10b4519024258b8962777fa8d4Eli Friedman else 690f52bbeb1ce55aa10b4519024258b8962777fa8d4Eli Friedman CGF.EmitStoreThroughLValue(RValue::get(NextVal), LV, ValTy); 6917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // If this is a postinc, return the value read from memory, otherwise use the 6937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // updated value. 6947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return isPre ? NextVal : InVal; 6957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 6967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 6997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 7007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNeg(Op, "neg"); 7017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 7027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 7047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 7057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNot(Op, "neg"); 7067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 7077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 7097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Compare operand to zero. 7107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 7117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Invert value. 7137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // TODO: Could dynamically modify easy computations here. For example, if 7147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // the operand is an icmp ne, turn into icmp eq. 7157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BoolVal = Builder.CreateNot(BoolVal, "lnot"); 7167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 7187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateZExt(BoolVal, CGF.LLVMIntTy, "lnot.ext"); 7197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 7207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7210518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// VisitSizeOfAlignOfExpr - Return the size or alignment of the type of 7220518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// argument of the sizeof expression as an integer. 7230518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlValue * 7240518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) { 7250518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl QualType TypeToSize = E->getTypeOfArgument(); 726f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isSizeOf()) { 727f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (const VariableArrayType *VAT = 728f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.getContext().getAsVariableArrayType(TypeToSize)) { 729f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isArgumentType()) { 730f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // sizeof(type) - make sure to emit the VLA size. 731f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.EmitVLASize(TypeToSize); 7328f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman } else { 7338f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // C99 6.5.3.4p2: If the argument is an expression of type 7348f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // VLA, it is evaluated. 7358f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman CGF.EmitAnyExpr(E->getArgumentExpr()); 736f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman } 7376cd586d2668653501ecd73d53e81cbc76db3a18cAnders Carlsson 73896f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson return CGF.GetVLASize(VAT); 739b50525ba0e996bc072cdb76152fcfe0bc64bb72aAnders Carlsson } 7405d46315ca3cbbfe0d0f5f65520b618fb05dd4446Anders Carlsson } 741f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman 742f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // If this isn't sizeof(vla), the result must be constant; use the 743f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // constant folding logic so we don't have to duplicate it here. 744f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman Expr::EvalResult Result; 745f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman E->Evaluate(Result, CGF.getContext()); 746f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman return llvm::ConstantInt::get(Result.Val.getInt()); 7477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 7487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 74946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 75046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 7519b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (Op->getType()->isAnyComplexType()) 75246f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return CGF.EmitComplexExpr(Op).first; 75346f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return Visit(Op); 75446f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 75546f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 75646f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 7579b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner if (Op->getType()->isAnyComplexType()) 75846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return CGF.EmitComplexExpr(Op).second; 75936f8406db837957b24b926fd657af909e1b12665Chris Lattner 76036f8406db837957b24b926fd657af909e1b12665Chris Lattner // __imag on a scalar returns zero. Emit it the subexpr to ensure side 76136f8406db837957b24b926fd657af909e1b12665Chris Lattner // effects are evaluated. 76236f8406db837957b24b926fd657af909e1b12665Chris Lattner CGF.EmitScalarExpr(Op); 76336f8406db837957b24b926fd657af909e1b12665Chris Lattner return llvm::Constant::getNullValue(ConvertType(E->getType())); 76446f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 76546f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 7665a1deb8d9c0722beae28d693fa137bbb942bd11fAnders CarlssonValue *ScalarExprEmitter::VisitUnaryOffsetOf(const UnaryOperator *E) 7675a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson{ 76835183aca180a2b9b2c637cd625a40a7e147d6a32Eli Friedman Value* ResultAsPtr = EmitLValue(E->getSubExpr()).getAddress(); 769769e411b72465a63454cdd416ff26ff313d43505Eli Friedman const llvm::Type* ResultType = ConvertType(E->getType()); 77035183aca180a2b9b2c637cd625a40a7e147d6a32Eli Friedman return Builder.CreatePtrToInt(ResultAsPtr, ResultType, "offsetof"); 7715a1deb8d9c0722beae28d693fa137bbb942bd11fAnders Carlsson} 77246f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 7737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 7747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Binary Operators 7757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 7767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerBinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 7787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BinOpInfo Result; 7797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.LHS = Visit(E->getLHS()); 7807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.RHS = Visit(E->getRHS()); 7811f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Result.Ty = E->getType(); 7827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.E = E; 7837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Result; 7847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 7857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7863ccf774256382ef9aa95028eaad82f54a3d0b0adChris LattnerValue *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 7871f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 7881f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner QualType LHSTy = E->getLHS()->getType(), RHSTy = E->getRHS()->getType(); 7891f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 7901f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo OpInfo; 7911f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 792ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman if (E->getComputationResultType()->isAnyComplexType()) { 793daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // This needs to go through the complex expression emitter, but 794ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // it's a tad complicated to do that... I'm leaving it out for now. 795ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // (Note that we do actually need the imaginary part of the RHS for 796ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // multiplication and division.) 797ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman CGF.ErrorUnsupported(E, "complex compound assignment"); 798ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 7991f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 8008c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 801ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // Load/convert the LHS. 802ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman LValue LHSLV = EmitLValue(E->getLHS()); 803ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy); 804ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 805ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman E->getComputationLHSType()); 806ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // Emit the RHS. 807ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.RHS = Visit(E->getRHS()); 808ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.Ty = E->getComputationResultType(); 8091f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner OpInfo.E = E; 8101f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 8111f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Expand the binary operator. 8121f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *Result = (this->*Func)(OpInfo); 8131f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 8148c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Convert the result back to the LHS type. 815ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 816ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman 817ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar // Store the result value into the LHS lvalue. Bit-fields are 818371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // handled specially because the result is altered by the store, 819371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // i.e., [C99 6.5.16p1] 'An assignment expression has the value of 820371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // the left operand after the assignment...'. 8211849128c7d88247d914f05efe4c03907f0932174Eli Friedman if (LHSLV.isBitfield()) 822ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy, 823ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar &Result); 824ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar else 825ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy); 826ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar 8271f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner return Result; 8281f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner} 8291f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 8301f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 8317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 832b3ab8dc7d3b2e24259b990ac4ad75abfd07fa1f9Nate Begeman if (Ops.LHS->getType()->isFPOrFPVector()) 8337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 8341f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner else if (Ops.Ty->isUnsignedIntegerType()) 8357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 8367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 8377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 8387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 8397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 8407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 8417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Rem in C can't be a floating point type: C99 6.5.5p2. 8421f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner if (Ops.Ty->isUnsignedIntegerType()) 8437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 8447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 8457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 8467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 8477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 8482add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike StumpValue *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 8492add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned IID; 8502add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned OpID = 0; 8515d8b2cf9fd704f6ca5e33525803a65421c0b440eMike Stump 852035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump switch (Ops.E->getOpcode()) { 853035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Add: 854035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::AddAssign: 855035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 1; 856035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::sadd_with_overflow; 857035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 858035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Sub: 859035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::SubAssign: 860035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 2; 861035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::ssub_with_overflow; 862035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 863035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::Mul: 864035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump case BinaryOperator::MulAssign: 865035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 3; 866035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::smul_with_overflow; 867035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 868035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump default: 869035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump assert(false && "Unsupported operation for overflow detection"); 870ab4eff620a9ce0ea62cdf29529a66c2c98d116f5Daniel Dunbar IID = 0; 871035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump } 872035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID <<= 1; 873035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID |= 1; 874035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump 8752add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 8762add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 8772add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1); 8782add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 8792add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 8802add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 8812add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 8822add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 8832add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Branch in case of overflow. 8842add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::BasicBlock *initialBB = Builder.GetInsertBlock(); 8852add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::BasicBlock *overflowBB = 8862add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump CGF.createBasicBlock("overflow", CGF.CurFn); 8872add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::BasicBlock *continueBB = 8882add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump CGF.createBasicBlock("overflow.continue", CGF.CurFn); 8892add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 8902add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateCondBr(overflow, overflowBB, continueBB); 8912add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 8922add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Handle overflow 8932add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 8942add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(overflowBB); 8952add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 8962add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Handler is: 8972add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // long long *__overflow_handler)(long long a, long long b, char op, 8982add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // char width) 8992add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump std::vector<const llvm::Type*> handerArgTypes; 9002add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump handerArgTypes.push_back(llvm::Type::Int64Ty); 9012add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump handerArgTypes.push_back(llvm::Type::Int64Ty); 9022add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump handerArgTypes.push_back(llvm::Type::Int8Ty); 9032add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump handerArgTypes.push_back(llvm::Type::Int8Ty); 9042add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::FunctionType *handlerTy = llvm::FunctionType::get(llvm::Type::Int64Ty, 9052add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump handerArgTypes, false); 9062add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Value *handlerFunction = 9072add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump CGF.CGM.getModule().getOrInsertGlobal("__overflow_handler", 9082add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::PointerType::getUnqual(handlerTy)); 9092add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump handlerFunction = Builder.CreateLoad(handlerFunction); 9102add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 9112add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Value *handlerResult = Builder.CreateCall4(handlerFunction, 9122add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateSExt(Ops.LHS, llvm::Type::Int64Ty), 9132add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateSExt(Ops.RHS, llvm::Type::Int64Ty), 9142add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::ConstantInt::get(llvm::Type::Int8Ty, OpID), 9152add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::ConstantInt::get(llvm::Type::Int8Ty, 9162add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump cast<llvm::IntegerType>(opTy)->getBitWidth())); 9172add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 9182add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump handlerResult = Builder.CreateTrunc(handlerResult, opTy); 9192add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 9202add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateBr(continueBB); 9212add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 9222add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Set up the continuation 9232add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(continueBB); 9242add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Get the correct result 9252add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::PHINode *phi = Builder.CreatePHI(opTy); 9262add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump phi->reserveOperandSpace(2); 9272add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump phi->addIncoming(result, initialBB); 9282add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump phi->addIncoming(handlerResult, overflowBB); 9292add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 9302add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump return phi; 9312add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump} 9327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 9337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { 9342add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump if (!Ops.Ty->isPointerType()) { 935035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump if (CGF.getContext().getLangOptions().OverflowChecking 936035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump && Ops.Ty->isSignedIntegerType()) 9372add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump return EmitOverflowCheckedBinOp(Ops); 9387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 9392add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 940daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 941daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman if (Ops.Ty->getAsPointerType()->isVariableArrayType()) { 942daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size 943daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman CGF.ErrorUnsupported(Ops.E, "VLA pointer addition"); 944daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 9458f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Value *Ptr, *Idx; 9468f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Expr *IdxExp; 947b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar const PointerType *PT; 948b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if ((PT = Ops.E->getLHS()->getType()->getAsPointerType())) { 9498f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.LHS; 9508f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.RHS; 9518f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner IdxExp = Ops.E->getRHS(); 9528f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } else { // int + pointer 953b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar PT = Ops.E->getRHS()->getType()->getAsPointerType(); 954b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar assert(PT && "Invalid add expr"); 9558f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.RHS; 9568f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.LHS; 9578f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner IdxExp = Ops.E->getLHS(); 9588f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 9598f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner 9608f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 9617cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 9628f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // Zero or sign extend the pointer value based on whether the index is 9638f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // signed or not. 9647cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta const llvm::Type *IdxType = llvm::IntegerType::get(CGF.LLVMPointerWidth); 9659619662a1d42e2008b865d3459c0677e149dad1bChris Lattner if (IdxExp->getType()->isSignedIntegerType()) 9668f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 9678f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner else 9688f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 9698f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 970b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar 971b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // Explicitly handle GNU void* and function pointer arithmetic 972b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // extensions. The GNU void* casts amount to no-ops since our void* 973b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // type is i8*, but this is future proof. 974b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar const QualType ElementType = PT->getPointeeType(); 975b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (ElementType->isVoidType() || ElementType->isFunctionType()) { 976b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar const llvm::Type *i8Ty = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 977b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 978b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "sub.ptr"); 979b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 980b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar } 9818f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner 9828f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner return Builder.CreateGEP(Ptr, Idx, "add.ptr"); 9837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 9847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 9857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { 9862add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump if (!isa<llvm::PointerType>(Ops.LHS->getType())) { 987035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump if (CGF.getContext().getLangOptions().OverflowChecking 988035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump && Ops.Ty->isSignedIntegerType()) 9892add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump return EmitOverflowCheckedBinOp(Ops); 9907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 9912add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 9921f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 993daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman if (Ops.E->getLHS()->getType()->getAsPointerType()->isVariableArrayType()) { 994daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size for 995daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-int 996daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the division needs to account for the VLA size for 997daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-ptr. 998daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman CGF.ErrorUnsupported(Ops.E, "VLA pointer subtraction"); 999daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 1000daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 1001b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar const QualType LHSType = Ops.E->getLHS()->getType(); 1002b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar const QualType LHSElementType = LHSType->getAsPointerType()->getPointeeType(); 10038c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar if (!isa<llvm::PointerType>(Ops.RHS->getType())) { 10048c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - int 10058c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *Idx = Ops.RHS; 10068c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 10077cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 10088c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Zero or sign extend the pointer value based on whether the index is 10098c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // signed or not. 10107cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta const llvm::Type *IdxType = llvm::IntegerType::get(CGF.LLVMPointerWidth); 10118c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar if (Ops.E->getRHS()->getType()->isSignedIntegerType()) 10128c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 10138c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar else 10148c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 10158c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 10168c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateNeg(Idx, "sub.ptr.neg"); 1017b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar 1018b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // Explicitly handle GNU void* and function pointer arithmetic 1019b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // extensions. The GNU void* casts amount to no-ops since our 1020b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // void* type is i8*, but this is future proof. 1021b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 1022b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar const llvm::Type *i8Ty = llvm::PointerType::getUnqual(llvm::Type::Int8Ty); 1023b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1024b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr"); 1025b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1026b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar } 1027b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar 10288c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar return Builder.CreateGEP(Ops.LHS, Idx, "sub.ptr"); 1029820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar } else { 10308c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - pointer 10318c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *LHS = Ops.LHS; 10328c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *RHS = Ops.RHS; 10331f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 10348c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar uint64_t ElementSize; 1035820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar 1036e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Handle GCC extension for pointer arithmetic on void* and function pointer 1037e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // types. 1038e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 10398c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar ElementSize = 1; 10408c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } else { 10418c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar ElementSize = CGF.getContext().getTypeSize(LHSElementType) / 8; 10428c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 10438c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 10448c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar const llvm::Type *ResultType = ConvertType(Ops.Ty); 10458c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); 10468c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 10478c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 10488c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 1049e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Optimize out the shift for element size of 1. 1050e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner if (ElementSize == 1) 1051e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner return BytesBetween; 1052e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner 10538c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // HACK: LLVM doesn't have an divide instruction that 'knows' there is no 10548c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // remainder. As such, we handle common power-of-two cases here to generate 10558c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // better code. See PR2247. 10568c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar if (llvm::isPowerOf2_64(ElementSize)) { 10578c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *ShAmt = 10588c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar llvm::ConstantInt::get(ResultType, llvm::Log2_64(ElementSize)); 10598c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar return Builder.CreateAShr(BytesBetween, ShAmt, "sub.ptr.shr"); 10608c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 10618c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 10628c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Otherwise, do a full sdiv. 10638c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *BytesPerElt = llvm::ConstantInt::get(ResultType, ElementSize); 10648c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar return Builder.CreateSDiv(BytesBetween, BytesPerElt, "sub.ptr.div"); 10657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 10667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 10677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 10687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 10697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 10707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 10717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 10727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 10737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 10747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 10757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateShl(Ops.LHS, RHS, "shl"); 10767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 10777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 10787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 10797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 10807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 10817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 10827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 10837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 10847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 10851f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner if (Ops.Ty->isUnsignedIntegerType()) 10867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 10877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 10887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 10897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 10907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 10917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc) { 10924f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *Result; 10937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner QualType LHSTy = E->getLHS()->getType(); 10947a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman if (!LHSTy->isAnyComplexType() && !LHSTy->isVectorType()) { 10957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS = Visit(E->getLHS()); 10967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 10977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 10987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (LHS->getType()->isFloatingPoint()) { 10997a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 11007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 1101ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman } else if (LHSTy->isSignedIntegerType()) { 1102ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 11037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 11047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 1105ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman // Unsigned integers and pointers. 1106ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 11077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 11087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 11097a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman } else if (LHSTy->isVectorType()) { 11107a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Value *LHS = Visit(E->getLHS()); 11117a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Value *RHS = Visit(E->getRHS()); 11127a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman 11137a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman if (LHS->getType()->isFPOrFPVector()) { 11147a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateVFCmp((llvm::CmpInst::Predicate)FCmpOpc, 11157a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman LHS, RHS, "cmp"); 11167a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman } else if (LHSTy->isUnsignedIntegerType()) { 11177a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateVICmp((llvm::CmpInst::Predicate)UICmpOpc, 11187a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman LHS, RHS, "cmp"); 11197a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman } else { 11207a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman // Signed integers and pointers. 11217a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateVICmp((llvm::CmpInst::Predicate)SICmpOpc, 11227a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman LHS, RHS, "cmp"); 11237a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman } 11247a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman return Result; 11257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 11267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex Comparison: can only be an equality comparison. 11277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 11287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 11297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11309619662a1d42e2008b865d3459c0677e149dad1bChris Lattner QualType CETy = LHSTy->getAsComplexType()->getElementType(); 11317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11324f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *ResultR, *ResultI; 11337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (CETy->isRealFloatingType()) { 11347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 11357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 11367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 11377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 11387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 11397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex comparisons can only be equality comparisons. As such, signed 11407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // and unsigned opcodes are the same. 11417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 11427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 11437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 11447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 11457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 11467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getOpcode() == BinaryOperator::EQ) { 11487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 11497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 11507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E->getOpcode() == BinaryOperator::NE && 11517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Complex comparison other than == or != ?"); 11527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 11537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 11547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 115532f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes 115632f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 11577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 11587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 11607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LValue LHS = EmitLValue(E->getLHS()); 11617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 11627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1163ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar // Store the value into the LHS. Bit-fields are handled specially 1164371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // because the result is altered by the store, i.e., [C99 6.5.16p1] 1165371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // 'An assignment expression has the value of the left operand after 1166daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // the assignment...'. 11671849128c7d88247d914f05efe4c03907f0932174Eli Friedman if (LHS.isBitfield()) 1168ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType(), 1169ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar &RHS); 1170ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar else 1171ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType()); 117285c59edda02df48fae8dc85049743319bc6e7e89Daniel Dunbar 11737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Return the RHS. 11747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return RHS; 11757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 11767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 11777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 117820eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 117920eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 && X, just emit X without inserting the control flow. 118020eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 118120eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == 1) { // If we have 1 && X, just emit X. 11820946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 11830946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // ZExt result to int. 11840946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return Builder.CreateZExt(RHSCond, CGF.LLVMIntTy, "land.ext"); 11850946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 118620eb09d562b80420a3328be789547af354bf3e36Chris Lattner 118720eb09d562b80420a3328be789547af354bf3e36Chris Lattner // 0 && RHS: If it is safe, just elide the RHS, and return 0. 118820eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 118920eb09d562b80420a3328be789547af354bf3e36Chris Lattner return llvm::Constant::getNullValue(CGF.LLVMIntTy); 11900946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 11910946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner 11929615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 11939615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 119420eb09d562b80420a3328be789547af354bf3e36Chris Lattner 1195f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is false, go to the failure (cont) block. 1196f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 1197f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1198f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 1199f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be false. Start 1200f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 1201f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::Int1Ty, "", ContBlock); 1202f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 1203f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 1204f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 1205f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->addIncoming(llvm::ConstantInt::getFalse(), *PI); 12067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 12087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 12097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 12117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 1212f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1213f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 1214f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 12157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 12167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 12177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 12197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateZExt(PN, CGF.LLVMIntTy, "land.ext"); 12207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 122320eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 122420eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 || X, just emit X without inserting the control flow. 122520eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 122620eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == -1) { // If we have 0 || X, just emit X. 12270946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 12280946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner // ZExt result to int. 12290946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner return Builder.CreateZExt(RHSCond, CGF.LLVMIntTy, "lor.ext"); 12300946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 123120eb09d562b80420a3328be789547af354bf3e36Chris Lattner 12328de8d1d3f2e21e4a72ac294276930ad293a3a765Eli Friedman // 1 || RHS: If it is safe, just elide the RHS, and return 1. 123320eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 12348de8d1d3f2e21e4a72ac294276930ad293a3a765Eli Friedman return llvm::ConstantInt::get(CGF.LLVMIntTy, 1); 12350946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 12360946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner 12379615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 12389615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 12397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1240f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is true, go to the success (cont) block. 1241f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 1242f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1243f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 1244f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be true. Start 1245f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 1246f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::Int1Ty, "", ContBlock); 1247f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 1248f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 1249f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 1250f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->addIncoming(llvm::ConstantInt::getTrue(), *PI); 1251f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 1252f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit the RHS condition as a bool value. 12537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 12547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 12557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 12577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 12587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1259f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 1260f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 1261f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBlock(ContBlock); 12627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 12637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 12657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateZExt(PN, CGF.LLVMIntTy, "lor.ext"); 12667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 12697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitStmt(E->getLHS()); 1270a448fb2da03ece39978784793eea68760e8205a1Daniel Dunbar CGF.EnsureInsertPoint(); 12717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getRHS()); 12727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Other Operators 12767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12789802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 12799802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// expression is cheap enough and side-effect-free enough to evaluate 12809802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// unconditionally instead of conditionally. This is used to convert control 12819802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// flow into selects in some cases. 12829802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattnerstatic bool isCheapEnoughToEvaluateUnconditionally(const Expr *E) { 12839802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) 12849802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr()); 12859802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 12869802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // TODO: Allow anything we can constant fold to an integer or fp constant. 12879802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) || 12889802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner isa<FloatingLiteral>(E)) 12899802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 12909802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 12919802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // Non-volatile automatic variables too, to get "cond ? X : Y" where 12929802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // X and Y are local variables. 12939802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 12949802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 12959802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (VD->hasLocalStorage() && !VD->getType().isVolatileQualified()) 12969802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 12979802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 12989802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return false; 12999802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner} 13009802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 13019802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 13027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter:: 13037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerVisitConditionalOperator(const ConditionalOperator *E) { 130431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the condition constant folds and can be elided, try to avoid emitting 130531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the condition and the dead arm. 130631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getCond())){ 1307c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner Expr *Live = E->getLHS(), *Dead = E->getRHS(); 130831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (Cond == -1) 1309c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner std::swap(Live, Dead); 131031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner 131131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the dead side doesn't have labels we need, and if the Live side isn't 131231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the gnu missing ?: extension (which we could handle, but don't bother 131331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // to), just emit the Live part. 131431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if ((!Dead || !CGF.ContainsLabel(Dead)) && // No labels in dead part 131531a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Live) // Live part isn't missing. 131631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return Visit(Live); 1317c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner } 1318c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner 13199802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 13209802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // If this is a really simple expression (like x ? 4 : 5), emit this as a 13219802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // select instead of as control flow. We can only do this if it is cheap and 1322531a550531c144a58438f187816abbf1879e1c4eChris Lattner // safe to evaluate the LHS and RHS unconditionally. 13239802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (E->getLHS() && isCheapEnoughToEvaluateUnconditionally(E->getLHS()) && 13249802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner isCheapEnoughToEvaluateUnconditionally(E->getRHS())) { 13259802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *CondV = CGF.EvaluateExprAsBool(E->getCond()); 13269802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *LHS = Visit(E->getLHS()); 13279802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *RHS = Visit(E->getRHS()); 13289802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 13299802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner } 13309802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 13319802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 1332be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 1333be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 13349615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 1335035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Value *CondVal = 0; 1336035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner 133712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // If we don't have the GNU missing condition extension, emit a branch on 133812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // bool the normal way. 133912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner if (E->getLHS()) { 134012d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for 134112d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the branch on bool. 134212d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 134312d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner } else { 134412d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, for the ?: extension, evaluate the conditional and then 134512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // convert it to bool the hard way. We do this explicitly because we need 134612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the unconverted value for the missing middle value of the ?:. 1347035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CondVal = CGF.EmitScalarExpr(E->getCond()); 134812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner 134912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // In some cases, EmitScalarConversion will delete the "CondVal" expression 135012d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // if there are no extra uses (an optimization). Inhibit this by making an 135112d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // extra dead use, because we're going to add a use of CondVal later. We 135212d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // don't use the builder for this, because we don't want it to get optimized 135312d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // away. This leaves dead code, but the ?: extension isn't common. 135412d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner new llvm::BitCastInst(CondVal, CondVal->getType(), "dummy?:holder", 135512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner Builder.GetInsertBlock()); 135612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner 1357035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Value *CondBoolVal = 1358035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.EmitScalarConversion(CondVal, E->getCond()->getType(), 1359035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.getContext().BoolTy); 1360035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock); 1361035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner } 13627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(LHSBlock); 13647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the GNU extension for missing LHS. 1366a21ddb30e56026967d58e26c5212744e1831305bChris Lattner Value *LHS; 1367a21ddb30e56026967d58e26c5212744e1831305bChris Lattner if (E->getLHS()) 1368856226c37ff10955c7f3f07ce6fa9522da23a3a5Eli Friedman LHS = Visit(E->getLHS()); 1369a21ddb30e56026967d58e26c5212744e1831305bChris Lattner else // Perform promotions, to handle cases like "short ?: int" 1370a21ddb30e56026967d58e26c5212744e1831305bChris Lattner LHS = EmitScalarConversion(CondVal, E->getCond()->getType(), E->getType()); 1371a21ddb30e56026967d58e26c5212744e1831305bChris Lattner 13727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHSBlock = Builder.GetInsertBlock(); 1373d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 13747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 13767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1377856226c37ff10955c7f3f07ce6fa9522da23a3a5Eli Friedman Value *RHS = Visit(E->getRHS()); 13787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 1379d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 13807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 13827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1383108f55d6fd9a1c0e753eb8e046cb1f1b81d77a76Nuno Lopes if (!LHS || !RHS) { 13842202bce80fc72d067cbe67dc1512f7b45351fd31Chris Lattner assert(E->getType()->isVoidType() && "Non-void value should have a value"); 13852202bce80fc72d067cbe67dc1512f7b45351fd31Chris Lattner return 0; 13862202bce80fc72d067cbe67dc1512f7b45351fd31Chris Lattner } 13872202bce80fc72d067cbe67dc1512f7b45351fd31Chris Lattner 13887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Create a PHI node for the real part. 13897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond"); 13907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->reserveOperandSpace(2); 13917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(LHS, LHSBlock); 13927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHS, RHSBlock); 13937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return PN; 13947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 13977976932a1c256d447316ffac58e9821417725e34Eli Friedman return Visit(E->getChosenSubExpr(CGF.getContext())); 13987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14002202bce80fc72d067cbe67dc1512f7b45351fd31Chris LattnerValue *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 14014fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 1402ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 1403ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 1404ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson // If EmitVAArg fails, we fall back to the LLVM instruction. 1405ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson if (!ArgPtr) 1406ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 1407ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 1408ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateLoad(ArgPtr); 14097c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson} 14107c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 1411df6b68c9487aed2042c7fc23db10a79f89083a11Mike StumpValue *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *BE) { 14120892099dbc640720400a1d9decd2733a09d733e5Mike Stump return CGF.BuildBlockLiteralTmp(BE); 1413df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump} 1414df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 14157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 14167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Entry Point into this File 14177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 14187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner/// EmitComplexExpr - Emit the computation of the specified expression of 14207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner/// complex type, ignoring the result. 14217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *CodeGenFunction::EmitScalarExpr(const Expr *E) { 14227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E && !hasAggregateLLVMType(E->getType()) && 14237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Invalid scalar expression to emit"); 14247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return ScalarExprEmitter(*this).Visit(const_cast<Expr*>(E)); 14267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14273707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 14283707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 14293707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 14304f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 14314f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 14323707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 14333707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner "Invalid scalar expression to emit"); 14343707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 14353707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 14364f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 14374f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner/// EmitComplexToScalarConversion - Emit a conversion from the specified 14384f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner/// complex type to the specified destination type, where the destination 14394f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner/// type is an LLVM scalar type. 14404f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 14414f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, 14424f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 14439b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 14444f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner "Invalid complex -> scalar conversion"); 14454f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 14464f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner DstTy); 14474f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 1448cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 1449cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders CarlssonValue *CodeGenFunction::EmitShuffleVector(Value* V1, Value *V2, ...) { 1450cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson assert(V1->getType() == V2->getType() && 1451cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson "Vector operands must be of the same type"); 1452cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson unsigned NumElements = 1453cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson cast<llvm::VectorType>(V1->getType())->getNumElements(); 1454cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 1455cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson va_list va; 1456cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson va_start(va, V2); 1457cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 1458cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson llvm::SmallVector<llvm::Constant*, 16> Args; 1459cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson for (unsigned i = 0; i < NumElements; i++) { 1460cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson int n = va_arg(va, int); 1461cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson assert(n >= 0 && n < (int)NumElements * 2 && 1462cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson "Vector shuffle index out of bounds!"); 1463cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, n)); 1464cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson } 1465cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 1466cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson const char *Name = va_arg(va, const char *); 1467cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson va_end(va); 1468cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 1469cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 1470cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 1471cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson return Builder.CreateShuffleVector(V1, V2, Mask, Name); 1472cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson} 1473cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 14746086bbd1799e22e75561c3d31dc9b923f0508fa5Anders Carlssonllvm::Value *CodeGenFunction::EmitVector(llvm::Value * const *Vals, 1475345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner unsigned NumVals, bool isSplat) { 14766086bbd1799e22e75561c3d31dc9b923f0508fa5Anders Carlsson llvm::Value *Vec 1477345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner = llvm::UndefValue::get(llvm::VectorType::get(Vals[0]->getType(), NumVals)); 14786086bbd1799e22e75561c3d31dc9b923f0508fa5Anders Carlsson 1479345f7209692b116ca433a3196c1e3c998e0ffcdeChris Lattner for (unsigned i = 0, e = NumVals; i != e; ++i) { 14804119d1aeca8016654d381ce079864058d1709571Nate Begeman llvm::Value *Val = isSplat ? Vals[0] : Vals[i]; 14816086bbd1799e22e75561c3d31dc9b923f0508fa5Anders Carlsson llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i); 14824119d1aeca8016654d381ce079864058d1709571Nate Begeman Vec = Builder.CreateInsertElement(Vec, Val, Idx, "tmp"); 14836086bbd1799e22e75561c3d31dc9b923f0508fa5Anders Carlsson } 14846086bbd1799e22e75561c3d31dc9b923f0508fa5Anders Carlsson 14856086bbd1799e22e75561c3d31dc9b923f0508fa5Anders Carlsson return Vec; 14866086bbd1799e22e75561c3d31dc9b923f0508fa5Anders Carlsson} 1487