CGExprScalar.cpp revision 61eee0ca33b29e102f11bab77c8b74cc00e2392b
17f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===// 27f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 37f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// The LLVM Compiler Infrastructure 47f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 77f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 87f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 97f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// This contains code to emit Expr nodes with scalar LLVM types as LLVM code. 117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1478ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel#include "clang/Frontend/CodeGenOptions.h" 157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "CodeGenFunction.h" 164c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall#include "CGCXXABI.h" 17f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian#include "CGObjCRuntime.h" 187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "CodeGenModule.h" 1978ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel#include "CGDebugInfo.h" 20de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 2198c5ead87d720d8b68b6f236c3c3579a388fc882Daniel Dunbar#include "clang/AST/DeclObjC.h" 2219cc4abea06a9b49e0e16a50d335c064cd723572Anders Carlsson#include "clang/AST/RecordLayout.h" 23de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/StmtVisitor.h" 2425ddea7f7835c4b1804e458a5c866cde0097430aChris Lattner#include "clang/Basic/TargetInfo.h" 257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "llvm/Constants.h" 267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "llvm/Function.h" 2785f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson#include "llvm/GlobalVariable.h" 287c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson#include "llvm/Intrinsics.h" 292add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump#include "llvm/Module.h" 30f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner#include "llvm/Support/CFG.h" 314e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump#include "llvm/Target/TargetData.h" 32c89bf69c9289d2b2305f2c267daacc7312391898Chris Lattner#include <cstdarg> 336aad91a43e26118c824d976661077819265d9bc0Ted Kremenek 347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing namespace clang; 357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing namespace CodeGen; 367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing llvm::Value; 377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Scalar Expression Emitter 407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4279ba2a6379f87fa137377c3f55ff993b9e5cc144Benjamin Kramernamespace { 437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerstruct BinOpInfo { 447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS; 457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS; 461f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner QualType Ty; // Computation Type. 479a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinaryOperator::Opcode Opcode; // Opcode of BinOp to perform 489a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const Expr *E; // Entire expr, for error unsupported. May not be binop. 497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 51404cd1669c3ba138a9ae0a619bd689cce5aae271John McCallstatic bool MustVisitNullValue(const Expr *E) { 52404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall // If a null pointer expression's type is the C++0x nullptr_t, then 53404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall // it's not necessarily a simple constant and it must be evaluated 54404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall // for its potential side effects. 55404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall return E->getType()->isNullPtrType(); 56404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall} 57404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 5885b4521e34dcd4a0a4a1f0819e1123128e5a3125Benjamin Kramerclass ScalarExprEmitter 597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner : public StmtVisitor<ScalarExprEmitter, Value*> { 607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction &CGF; 6145d196b8387dcefc4df26cda114fa34c6528e928Daniel Dunbar CGBuilderTy &Builder; 627f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreResultAssign; 63a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson llvm::LLVMContext &VMContext; 647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerpublic: 657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 667f79f9be5916c51c35da4f126b7c12596a101607Mike Stump ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false) 67db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira), 68a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson VMContext(cgf.getLLVMContext()) { 697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 70db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Utilities 737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 757f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool TestAndClearIgnoreResultAssign() { 769c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner bool I = IgnoreResultAssign; 779c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner IgnoreResultAssign = false; 789c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return I; 799c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner } 807f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); } 827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); } 83b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue EmitCheckedLValue(const Expr *E) { return CGF.EmitCheckedLValue(E); } 847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(LValue LV, QualType T) { 869b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitLoadOfLValue(LV, T).getScalarVal(); 877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 88db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// EmitLoadOfLValue - Given an expression with complex type that represents a 907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// value l-value, this method emits the address of the l-value, then loads 917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// and returns the result. 927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(const Expr *E) { 93b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump return EmitLoadOfLValue(EmitCheckedLValue(E), E->getType()); 947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 95db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 969abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner /// EmitConversionToBool - Convert the specified expression value to a 973420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner /// boolean (i1) truth value. This is equivalent to "Val != 0". 989abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner Value *EmitConversionToBool(Value *Src, QualType DstTy); 99db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1003707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// EmitScalarConversion - Emit a conversion from the specified type to the 1013707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// specified destination type, both of which are LLVM scalar types. 1024f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy); 1034f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 1044f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner /// EmitComplexToScalarConversion - Emit a conversion from the specified 105db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump /// complex type to the specified destination type, where the destination type 106db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump /// is an LLVM scalar type. 1074f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 1084f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy); 109df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 110a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson /// EmitNullValue - Emit a value that corresponds to null for the given type. 111a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson Value *EmitNullValue(QualType Ty); 112a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 113daa8e4e888758d55a7a759dd4a91b83921cef222John McCall /// EmitFloatToBoolConversion - Perform an FP to boolean conversion. 114daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Value *EmitFloatToBoolConversion(Value *V) { 115daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // Compare against 0.0 for fp scalars. 116daa8e4e888758d55a7a759dd4a91b83921cef222John McCall llvm::Value *Zero = llvm::Constant::getNullValue(V->getType()); 117daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return Builder.CreateFCmpUNE(V, Zero, "tobool"); 118daa8e4e888758d55a7a759dd4a91b83921cef222John McCall } 119daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 120daa8e4e888758d55a7a759dd4a91b83921cef222John McCall /// EmitPointerToBoolConversion - Perform a pointer to boolean conversion. 121daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Value *EmitPointerToBoolConversion(Value *V) { 122daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Value *Zero = llvm::ConstantPointerNull::get( 123daa8e4e888758d55a7a759dd4a91b83921cef222John McCall cast<llvm::PointerType>(V->getType())); 124daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return Builder.CreateICmpNE(V, Zero, "tobool"); 125daa8e4e888758d55a7a759dd4a91b83921cef222John McCall } 126daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 127daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Value *EmitIntToBoolConversion(Value *V) { 128daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // Because of the type rules of C, we often end up computing a 129daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // logical value, then zero extending it to int, then wanting it 130daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // as a logical value again. Optimize this common case. 131daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(V)) { 132daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (ZI->getOperand(0)->getType() == Builder.getInt1Ty()) { 133daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Value *Result = ZI->getOperand(0); 134daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // If there aren't any more uses, zap the instruction to save space. 135daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // Note that there can be more uses, for example if this 136daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // is the result of an assignment. 137daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (ZI->use_empty()) 138daa8e4e888758d55a7a759dd4a91b83921cef222John McCall ZI->eraseFromParent(); 139daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return Result; 140daa8e4e888758d55a7a759dd4a91b83921cef222John McCall } 141daa8e4e888758d55a7a759dd4a91b83921cef222John McCall } 142daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 14348431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.CreateIsNotNull(V, "tobool"); 144daa8e4e888758d55a7a759dd4a91b83921cef222John McCall } 145daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 1467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 1477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Visitor Methods 1487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 1497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 150af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *Visit(Expr *E) { 151af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian return StmtVisitor<ScalarExprEmitter, Value*>::Visit(E); 152af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian } 153af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian 1547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitStmt(Stmt *S) { 1557a9d49fd2bfac00e905b361ba76d26ab5b6c3b09Ted Kremenek S->dump(CGF.getContext().getSourceManager()); 1567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(0 && "Stmt can't have complex result type!"); 1577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 1587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitExpr(Expr *S); 160f51dc64f90851f636302dbaaf3f52c0524cdac36Fariborz Jahanian 161af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *VisitParenExpr(ParenExpr *PE) { 162af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian return Visit(PE->getSubExpr()); 163af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian } 164f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne Value *VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 165f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne return Visit(GE->getResultExpr()); 166f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne } 1677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Leaves. 1697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitIntegerLiteral(const IntegerLiteral *E) { 17048431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt(E->getValue()); 1717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitFloatingLiteral(const FloatingLiteral *E) { 173bc0a2226c7fcd18b29b6846049e2cfcb872d3593Owen Anderson return llvm::ConstantFP::get(VMContext, E->getValue()); 1747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCharacterLiteral(const CharacterLiteral *E) { 1764a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 177e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman } 178e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 1794a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 1807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 181ed8abf18329df67b0abcbb3a10458bd8c1d2a595Douglas Gregor Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) { 182a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1837267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis } 1843f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson Value *VisitGNUNullExpr(const GNUNullExpr *E) { 185a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1863f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson } 1870027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Value *VisitOffsetOfExpr(OffsetOfExpr *E); 188f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne Value *VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E); 1890ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar Value *VisitAddrLabelExpr(const AddrLabelExpr *E) { 190d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel()); 191d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return Builder.CreateBitCast(V, ConvertType(E->getType())); 1920ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar } 193db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1949370c8f4af43a98a6f16e65f5d88d58db846e374Douglas Gregor Value *VisitSizeOfPackExpr(SizeOfPackExpr *E) { 19548431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return llvm::ConstantInt::get(ConvertType(E->getType()),E->getPackLength()); 1969370c8f4af43a98a6f16e65f5d88d58db846e374Douglas Gregor } 197e996ffd240f20a1048179d7727a6ee3227261921John McCall 198e996ffd240f20a1048179d7727a6ee3227261921John McCall Value *VisitOpaqueValueExpr(OpaqueValueExpr *E) { 19956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (E->isGLValue()) 20056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E), E->getType()); 201e996ffd240f20a1048179d7727a6ee3227261921John McCall 202e996ffd240f20a1048179d7727a6ee3227261921John McCall // Otherwise, assume the mapping is the scalar directly. 20356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return CGF.getOpaqueRValueMapping(E).getScalarVal(); 204e996ffd240f20a1048179d7727a6ee3227261921John McCall } 2059370c8f4af43a98a6f16e65f5d88d58db846e374Douglas Gregor 2067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // l-values. 2077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitDeclRefExpr(DeclRefExpr *E) { 20828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 209189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall if (!E->Evaluate(Result, CGF.getContext())) 210189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall return EmitLoadOfLValue(E); 211189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 212189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall assert(!Result.HasSideEffects && "Constant declref with side-effect?!"); 213189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 214189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall llvm::Constant *C; 21548431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner if (Result.Val.isInt()) 21648431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner C = Builder.getInt(Result.Val.getInt()); 21748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner else if (Result.Val.isFloat()) 218189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall C = llvm::ConstantFP::get(VMContext, Result.Val.getFloat()); 21948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner else 220189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall return EmitLoadOfLValue(E); 221189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 222189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall // Make sure we emit a debug reference to the global variable. 223189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) { 224189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall if (!CGF.getContext().DeclMustBeEmitted(VD)) 225189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall CGF.EmitDeclRefExprDbgValue(E, C); 226189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall } else if (isa<EnumConstantDecl>(E->getDecl())) { 227189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall CGF.EmitDeclRefExprDbgValue(E, C); 228189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall } 229189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 230189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall return C; 2317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 232db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 233db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCSelectorExpr(E); 2349c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 235db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 236db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCProtocolExpr(E); 2379c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 238db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 2399c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return EmitLoadOfLValue(E); 2409c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 2410a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 242f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(E->getObjectKind() == OK_Ordinary && 243f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall "reached property reference without lvalue-to-rvalue"); 24485c59edda02df48fae8dc85049743319bc6e7e89Daniel Dunbar return EmitLoadOfLValue(E); 2459c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 2469c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar Value *VisitObjCMessageExpr(ObjCMessageExpr *E) { 247180ff3ac073c86bf7b5dbf48cfdfb7fc8252ce5fFariborz Jahanian if (E->getMethodDecl() && 248180ff3ac073c86bf7b5dbf48cfdfb7fc8252ce5fFariborz Jahanian E->getMethodDecl()->getResultType()->isReferenceType()) 249180ff3ac073c86bf7b5dbf48cfdfb7fc8252ce5fFariborz Jahanian return EmitLoadOfLValue(E); 2509c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return CGF.EmitObjCMessageExpr(E).getScalarVal(); 2510a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar } 2520a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar 25383dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian Value *VisitObjCIsaExpr(ObjCIsaExpr *E) { 254820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian LValue LV = CGF.EmitObjCIsaExpr(E); 255820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Value *V = CGF.EmitLoadOfLValue(LV, E->getType()).getScalarVal(); 25683dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian return V; 25783dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian } 25883dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian 2597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 260d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E); 26128665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Value *VisitMemberExpr(MemberExpr *E); 262213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); } 263be20bb558cae5352898e6a913e29d24d20134841Chris Lattner Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 264be20bb558cae5352898e6a913e29d24d20134841Chris Lattner return EmitLoadOfLValue(E); 265be20bb558cae5352898e6a913e29d24d20134841Chris Lattner } 26635634f5ed67966c9f1fde38420e79cc6515cd673Devang Patel 2670533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *VisitInitListExpr(InitListExpr *E); 268db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2693498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) { 2703cb18bcefe39756f3b079fa1a62b4c9cbf6a592fAnders Carlsson return CGF.CGM.EmitNullConstant(E->getType()); 2713498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor } 272d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *VisitCastExpr(CastExpr *E) { 273c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman // Make sure to evaluate VLA bounds now so that we have them for later. 274745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (E->getType()->isVariablyModifiedType()) 275745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian CGF.EmitVLASize(E->getType()); 276c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman 277592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson return EmitCastExpr(E); 2787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 279d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *EmitCastExpr(CastExpr *E); 2807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCallExpr(const CallExpr *E) { 282e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson if (E->getCallReturnType()->isReferenceType()) 283e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson return EmitLoadOfLValue(E); 284db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2859b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitCallExpr(E).getScalarVal(); 2867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2878f2926b73ed635afecd020da787af6a837601a2bDaniel Dunbar 2883379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner Value *VisitStmtExpr(const StmtExpr *E); 2894e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump 290a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike Stump Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E); 291db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Unary Operators. 2937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostDec(const UnaryOperator *E) { 2948c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2958c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, false); 2967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostInc(const UnaryOperator *E) { 2988c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2998c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, false); 3007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreDec(const UnaryOperator *E) { 3028c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 3038c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, true); 3047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreInc(const UnaryOperator *E) { 3068c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 3078c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, true); 3087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3098c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 310683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *EmitAddConsiderOverflowBehavior(const UnaryOperator *E, 311683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *InVal, 312683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *NextVal, 313683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev bool IsInc); 314683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 3158c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 3168c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre); 3178c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 3188c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 3197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryAddrOf(const UnaryOperator *E) { 3205808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall if (isa<MemberPointerType>(E->getType())) // never sugared 3215808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall return CGF.CGM.getMemberPointerConstant(E); 3225808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall 3237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLValue(E->getSubExpr()).getAddress(); 3247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 325fd569004b78124c1041feee75a1e311166268c8dJohn McCall Value *VisitUnaryDeref(const UnaryOperator *E) { 326fd569004b78124c1041feee75a1e311166268c8dJohn McCall if (E->getType()->isVoidType()) 327fd569004b78124c1041feee75a1e311166268c8dJohn McCall return Visit(E->getSubExpr()); // the actual value should be unused 328fd569004b78124c1041feee75a1e311166268c8dJohn McCall return EmitLoadOfLValue(E); 329fd569004b78124c1041feee75a1e311166268c8dJohn McCall } 3307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPlus(const UnaryOperator *E) { 3317f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // This differs from gcc, though, most likely due to a bug in gcc. 3327f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 3337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 3347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryMinus (const UnaryOperator *E); 3367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryNot (const UnaryOperator *E); 3377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryLNot (const UnaryOperator *E); 33846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryReal (const UnaryOperator *E); 33946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryImag (const UnaryOperator *E); 3407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryExtension(const UnaryOperator *E) { 3417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 3427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3438ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 3445f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson // C++ 34504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 34604421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 34704421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 3485f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson Value *VisitCXXThisExpr(CXXThisExpr *TE) { 3495f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson return CGF.LoadCXXThis(); 350db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 351db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3524765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall Value *VisitExprWithCleanups(ExprWithCleanups *E) { 3534765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall return CGF.EmitExprWithCleanups(E).getScalarVal(); 3547f6ad153565245026c7569314f65a4d4ff4ac41fAnders Carlsson } 355a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson Value *VisitCXXNewExpr(const CXXNewExpr *E) { 356a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson return CGF.EmitCXXNewExpr(E); 357a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson } 35860e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) { 35960e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson CGF.EmitCXXDeleteExpr(E); 36060e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson return 0; 36160e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson } 3629dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman Value *VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 36348431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt1(E->getValue()); 3649dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman } 365db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3666ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet Value *VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *E) { 367f187237d916afa97c491ac32fe98be7d335c5b63Francois Pichet return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 3686ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet } 3696ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet 37021ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley Value *VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) { 37121ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue()); 37221ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley } 37321ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley 374552622067dc45013d240f73952fece703f5e63bdJohn Wiegley Value *VisitExpressionTraitExpr(const ExpressionTraitExpr *E) { 375552622067dc45013d240f73952fece703f5e63bdJohn Wiegley return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue()); 376552622067dc45013d240f73952fece703f5e63bdJohn Wiegley } 377552622067dc45013d240f73952fece703f5e63bdJohn Wiegley 378a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) { 379a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // C++ [expr.pseudo]p1: 380db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // The result shall only be used as the operand for the function call 381a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // operator (), and the result of such a call has type void. The only 382a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // effect is the evaluation of the postfix-expression before the dot or 383a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // arrow. 384a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor CGF.EmitScalarExpr(E->getBase()); 385a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor return 0; 386a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor } 387db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 388c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 389a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 390c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson } 391756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 392756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson Value *VisitCXXThrowExpr(const CXXThrowExpr *E) { 393756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson CGF.EmitCXXThrowExpr(E); 394756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson return 0; 395756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson } 396756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 39798294def01c97e127fa6d812ebd944d37212828aSebastian Redl Value *VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) { 39848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt1(E->getValue()); 39998294def01c97e127fa6d812ebd944d37212828aSebastian Redl } 40098294def01c97e127fa6d812ebd944d37212828aSebastian Redl 4017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Binary Operators. 4027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitMul(const BinOpInfo &Ops) { 403575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (Ops.Ty->isSignedIntegerOrEnumerationType()) { 404a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 405a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 406a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul"); 407a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 408a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 409a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 410a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 411a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 412a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 413a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 414f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 41587415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul"); 4167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 4177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4188023030f76d334355b73d9c675d3870858aaf4fdChris Lattner bool isTrapvOverflowBehavior() { 4198023030f76d334355b73d9c675d3870858aaf4fdChris Lattner return CGF.getContext().getLangOptions().getSignedOverflowBehavior() 4208023030f76d334355b73d9c675d3870858aaf4fdChris Lattner == LangOptions::SOB_Trapping; 4218023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 4222add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Create a binary op that checks for overflow. 4232add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Currently only supports +, - and *. 4242add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); 4258023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Emit the overflow BB when -ftrapv option is activated. 4268023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitOverflowBB(llvm::BasicBlock *overflowBB) { 4278023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(overflowBB); 4288023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Function *Trap = CGF.CGM.getIntrinsic(llvm::Intrinsic::trap); 4298023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCall(Trap); 4308023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateUnreachable(); 4318023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 4328023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Check for undefined division and modulus behaviors. 4338023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops, 4348023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero,bool isDiv); 4357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitDiv(const BinOpInfo &Ops); 4367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitRem(const BinOpInfo &Ops); 4377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAdd(const BinOpInfo &Ops); 4387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitSub(const BinOpInfo &Ops); 4397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShl(const BinOpInfo &Ops); 4407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShr(const BinOpInfo &Ops); 4417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAnd(const BinOpInfo &Ops) { 4427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 4437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitXor(const BinOpInfo &Ops) { 4457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 4467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitOr (const BinOpInfo &Ops) { 4487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 4497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4511f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo EmitBinOps(const BinaryOperator *E); 4526a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 4536a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*F)(const BinOpInfo &), 454d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result); 4556a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 4563ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *EmitCompoundAssign(const CompoundAssignOperator *E, 4571f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 4581f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 4591f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Binary operators and binary compound assignment operators. 4601f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#define HANDLEBINOP(OP) \ 4613ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP(const BinaryOperator *E) { \ 4623ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return Emit ## OP(EmitBinOps(E)); \ 4633ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner } \ 4643ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 4653ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 4661f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 4677177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Mul) 4687177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Div) 4697177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Rem) 4707177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Add) 4717177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Sub) 4727177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shl) 4737177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shr) 4747177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(And) 4757177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Xor) 4767177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Or) 4771f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#undef HANDLEBINOP 4788c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 4797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Comparisons. 4807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 4817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc); 4827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#define VISITCOMP(CODE, UI, SI, FP) \ 4837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBin##CODE(const BinaryOperator *E) { \ 4847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 4857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::FCmpInst::FP); } 4867177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT) 4877177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT) 4887177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE) 4897177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE) 4907177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ) 4917177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE) 4927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#undef VISITCOMP 493db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinAssign (const BinaryOperator *E); 4957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLAnd (const BinaryOperator *E); 4977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLOr (const BinaryOperator *E); 4987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinComma (const BinaryOperator *E); 4997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 50025b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); } 50125b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); } 50225b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman 5037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Other Operators. 504df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump Value *VisitBlockExpr(const BlockExpr *BE); 50556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Value *VisitAbstractConditionalOperator(const AbstractConditionalOperator *); 5067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitChooseExpr(ChooseExpr *CE); 5077c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson Value *VisitVAArgExpr(VAArgExpr *VE); 5087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 5097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return CGF.EmitObjCStringLiteral(E); 5107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 51161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Value *VisitAsTypeExpr(AsTypeExpr *CE); 5127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 5137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} // end anonymous namespace. 5147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Utilities 5177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5199abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner/// EmitConversionToBool - Convert the specified expression value to a 5203420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner/// boolean (i1) truth value. This is equivalent to "Val != 0". 5219abc84e7ac4db891209fe67cc3a8c9690dc886efChris LattnerValue *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 522467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs"); 523db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 524daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (SrcType->isRealFloatingType()) 525daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitFloatToBoolConversion(Src); 526db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5270bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType)) 5280bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT); 529db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 530d1d66bcd6914ff82abdfa88dd25bb0b74cde3b99Daniel Dunbar assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 5319abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner "Unknown scalar type to convert"); 532db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 533daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (isa<llvm::IntegerType>(Src->getType())) 534daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitIntToBoolConversion(Src); 535db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 536daa8e4e888758d55a7a759dd4a91b83921cef222John McCall assert(isa<llvm::PointerType>(Src->getType())); 537daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitPointerToBoolConversion(Src); 5389abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner} 5399abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 5403707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 5413707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 5424f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 5434f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstType) { 5449619662a1d42e2008b865d3459c0677e149dad1bChris Lattner SrcType = CGF.getContext().getCanonicalType(SrcType); 5459619662a1d42e2008b865d3459c0677e149dad1bChris Lattner DstType = CGF.getContext().getCanonicalType(DstType); 5463707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (SrcType == DstType) return Src; 547db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 548cf289083ab007264fa3ea96d92f133339aee5d2dChris Lattner if (DstType->isVoidType()) return 0; 549db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5503707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 551ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstType->isBooleanType()) 552ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return EmitConversionToBool(Src, SrcType); 553db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5543707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner const llvm::Type *DstTy = ConvertType(DstType); 5553707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 5563707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Ignore conversions like int -> uint. 5573707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (Src->getType() == DstTy) 5583707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Src; 5593707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 560db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle pointer conversions next: pointers can only be converted to/from 561db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // other pointers and integers. Check for pointer types in terms of LLVM, as 562db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // some native types (like Obj-C id) may map to a pointer type. 563270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(DstTy)) { 5643707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // The source value may be an integer, or a pointer. 565191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson if (isa<llvm::PointerType>(Src->getType())) 5663707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Builder.CreateBitCast(Src, DstTy, "conv"); 567191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 5683707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 56925615424741bcce31fe52c896f76268f0307f00dEli Friedman // First, convert to the correct width so that we control the kind of 57025615424741bcce31fe52c896f76268f0307f00dEli Friedman // extension. 57177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 572575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool InputSigned = SrcType->isSignedIntegerOrEnumerationType(); 57325615424741bcce31fe52c896f76268f0307f00dEli Friedman llvm::Value* IntResult = 57425615424741bcce31fe52c896f76268f0307f00dEli Friedman Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 57525615424741bcce31fe52c896f76268f0307f00dEli Friedman // Then, cast to pointer. 57625615424741bcce31fe52c896f76268f0307f00dEli Friedman return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 5773707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 578db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 579270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(Src->getType())) { 5803707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Must be an ptr to int cast. 5813707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 58250b5a30db40322880340e957ad7d6d8d60bb4c5bAnders Carlsson return Builder.CreatePtrToInt(Src, DstTy, "conv"); 5833707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 584db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 585213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // A scalar can be splatted to an extended vector of the same element type 5862ef13e5abef0570a9f567b4671367275c05d4d34Nate Begeman if (DstType->isExtVectorType() && !SrcType->isVectorType()) { 5876fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Cast the scalar to element type 588183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType EltTy = DstType->getAs<ExtVectorType>()->getElementType(); 5896fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 5906fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 5916fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Insert the element in element zero of an undef vector 59203e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::Value *UnV = llvm::UndefValue::get(DstTy); 59348431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *Idx = Builder.getInt32(0); 5946fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 5956fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 5966fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Splat the element across to all elements 5976fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 5986fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 599fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner for (unsigned i = 0; i != NumElements; ++i) 60048431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(0)); 601db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 602fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 6036fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 6046fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman return Yay; 6056fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman } 6064119d1aeca8016654d381ce079864058d1709571Nate Begeman 6073b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner // Allow bitcast from vector to integer/fp of the same size. 6087019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson if (isa<llvm::VectorType>(Src->getType()) || 6093b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner isa<llvm::VectorType>(DstTy)) 6107019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson return Builder.CreateBitCast(Src, DstTy, "conv"); 611db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 6123707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Finally, we have the arithmetic types: real int/float. 6133707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(Src->getType())) { 614575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool InputSigned = SrcType->isSignedIntegerOrEnumerationType(); 615b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (isa<llvm::IntegerType>(DstTy)) 616b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 617b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else if (InputSigned) 618b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateSIToFP(Src, DstTy, "conv"); 619b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 620b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateUIToFP(Src, DstTy, "conv"); 6213707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 622db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 623f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(Src->getType()->isFloatingPointTy() && "Unknown real conversion"); 6243707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(DstTy)) { 625575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (DstType->isSignedIntegerOrEnumerationType()) 626b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToSI(Src, DstTy, "conv"); 627b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 628b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToUI(Src, DstTy, "conv"); 6293707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 6303707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 631f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(DstTy->isFloatingPointTy() && "Unknown real conversion"); 632b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstTy->getTypeID() < Src->getType()->getTypeID()) 633b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPTrunc(Src, DstTy, "conv"); 634b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 635b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPExt(Src, DstTy, "conv"); 6363707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 6373707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 638db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 639db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 640db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 6414f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter:: 6424f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerEmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 6434f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy) { 644ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Get the source element type. 645183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall SrcTy = SrcTy->getAs<ComplexType>()->getElementType(); 646db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 647ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 648ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstTy->isBooleanType()) { 649ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Complex != 0 -> (Real != 0) | (Imag != 0) 650ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 651ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 652ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return Builder.CreateOr(Src.first, Src.second, "tobool"); 653ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner } 654db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 6554f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 6564f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // the imaginary part of the complex value is discarded and the value of the 6574f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // real part is converted according to the conversion rules for the 658db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // corresponding real type. 6594f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return EmitScalarConversion(Src.first, SrcTy, DstTy); 6604f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 6614f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 662a40a9f31218c743e366322e34b59f0d4d4414198Anders CarlssonValue *ScalarExprEmitter::EmitNullValue(QualType Ty) { 6630bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) 6640bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 6650bab0cdab751248ca389a5592bcb70eac5d39260John McCall 6660bab0cdab751248ca389a5592bcb70eac5d39260John McCall return llvm::Constant::getNullValue(ConvertType(Ty)); 667a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson} 6684f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 6697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Visitor Methods 6717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitExpr(Expr *E) { 674488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGF.ErrorUnsupported(E, "scalar expression"); 6757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getType()->isVoidType()) 6767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 67703e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 6787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 6797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 680d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanValue *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 68137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Vector Mask Case 68237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 2 || 6833f4cb120fe574f7b80864f52a1999502a4f3a83dRafael Espindola (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { 68477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *LHS = CGF.EmitScalarExpr(E->getExpr(0)); 68577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *RHS = CGF.EmitScalarExpr(E->getExpr(1)); 68677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Mask; 68737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 68837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType()); 68937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman unsigned LHSElts = LTy->getNumElements(); 69037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 69137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 3) { 69237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = CGF.EmitScalarExpr(E->getExpr(2)); 69337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 69437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Shuffle LHS & RHS into one input vector. 69537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> concat; 69637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0; i != LHSElts; ++i) { 69748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner concat.push_back(Builder.getInt32(2*i)); 69848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner concat.push_back(Builder.getInt32(2*i+1)); 69937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 70037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 701fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner Value* CV = llvm::ConstantVector::get(concat); 70237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); 70337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHSElts *= 2; 70437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } else { 70537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = RHS; 70637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 70737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 70837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType()); 70937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant* EltMask; 71037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 71137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Treat vec3 like vec4. 71237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) 71337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 71437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+2))-1); 71537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else if ((LHSElts == 3) && (E->getNumSubExprs() == 2)) 71637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 71737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+1))-1); 71837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else 71937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 72037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts))-1); 72137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 72237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Mask off the high bits of each shuffle index. 72337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant *, 32> MaskV; 72437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) 72537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MaskV.push_back(EltMask); 72637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 727fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner Value* MaskBits = llvm::ConstantVector::get(MaskV); 72837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); 72937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 73037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = undef 73137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // mask = mask & maskbits 73237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // for each elt 73337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // n = extract mask i 73437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // x = extract val n 73537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = insert newv, x, i 73637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(), 73737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MTy->getNumElements()); 73837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* NewV = llvm::UndefValue::get(RTy); 73937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) { 74048431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Value *Indx = Builder.getInt32(i); 74137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateExtractElement(Mask, Indx, "shuf_idx"); 74277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext"); 74337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 74437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 74537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { 74637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *cmpIndx, *newIndx; 74748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner cmpIndx = Builder.CreateICmpUGT(Indx, Builder.getInt32(3), 74837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "cmp_shuf_idx"); 74948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner newIndx = Builder.CreateSub(Indx, Builder.getInt32(1), "shuf_idx_adj"); 75037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx"); 75137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 75237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt"); 75337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman NewV = Builder.CreateInsertElement(NewV, VExt, Indx, "shuf_ins"); 75437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 75537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman return NewV; 756d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 75737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 758d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 759d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 76037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 76137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 7620eb47fc01849a94bac7fda236134f9301eff688bEli Friedman const llvm::VectorType *VTy = cast<llvm::VectorType>(V1->getType()); 76337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> indices; 76437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 7650eb47fc01849a94bac7fda236134f9301eff688bEli Friedman unsigned Idx = E->getShuffleMaskIdx(CGF.getContext(), i-2); 7660eb47fc01849a94bac7fda236134f9301eff688bEli Friedman if (VTy->getNumElements() == 3 && Idx > 3) 7670eb47fc01849a94bac7fda236134f9301eff688bEli Friedman Idx -= 1; 7680eb47fc01849a94bac7fda236134f9301eff688bEli Friedman indices.push_back(Builder.getInt32(Idx)); 76937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 77037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 771fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner Value *SV = llvm::ConstantVector::get(indices); 772d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 773d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 77428665272c36cccb1014a6ea1217354b0519e2b59Eli FriedmanValue *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) { 77528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 77628665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 77728665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->isArrow()) 77828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman CGF.EmitScalarExpr(E->getBase()); 77928665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman else 78028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman EmitLValue(E->getBase()); 78148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt(Result.Val.getInt()); 78228665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 78378ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel 78478ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // Emit debug info for aggregate now, if it was delayed to reduce 78578ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // debug info size. 78678ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel CGDebugInfo *DI = CGF.getDebugInfo(); 78778ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (DI && CGF.CGM.getCodeGenOpts().LimitDebugInfo) { 78878ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel QualType PQTy = E->getBase()->IgnoreParenImpCasts()->getType(); 78978ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (const PointerType * PTy = dyn_cast<PointerType>(PQTy)) 79049c8465f14fc3b2e1a32c7016ad3fb4e2cf8d466Devang Patel if (FieldDecl *M = dyn_cast<FieldDecl>(E->getMemberDecl())) 79178ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel DI->getOrCreateRecordType(PTy->getPointeeType(), 79278ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel M->getParent()->getLocation()); 7937fa8ab2e77f5703d0adf14e4d98f1edc1e66505dDevang Patel } 79428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return EmitLoadOfLValue(E); 79528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman} 796d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 7977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 7987f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 7997f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 8007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Emit subscript expressions in rvalue context's. For most cases, this just 8017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // loads the lvalue formed by the subscript expr. However, we have to be 8027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // careful, because the base of a vector subscript is occasionally an rvalue, 8037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // so we can't get it as an lvalue. 8047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (!E->getBase()->getType()->isVectorType()) 8057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 806db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 8077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the vector case. The base must be a vector, the index must be an 8087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // integer value. 8097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Base = Visit(E->getBase()); 8107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Idx = Visit(E->getIdx()); 811575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool IdxSigned = E->getIdx()->getType()->isSignedIntegerOrEnumerationType(); 81277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast"); 8137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateExtractElement(Base, Idx, "vecext"); 8147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 8157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 8160533b3020ca39898751d4200feed776861dcd1ceNate Begemanstatic llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, 8170533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned Off, const llvm::Type *I32Ty) { 8180533b3020ca39898751d4200feed776861dcd1ceNate Begeman int MV = SVI->getMaskValue(Idx); 8190533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (MV == -1) 8200533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::UndefValue::get(I32Ty); 8210533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::ConstantInt::get(I32Ty, Off+MV); 8220533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 8230533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8240533b3020ca39898751d4200feed776861dcd1ceNate BegemanValue *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { 8250533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool Ignore = TestAndClearIgnoreResultAssign(); 8260533b3020ca39898751d4200feed776861dcd1ceNate Begeman (void)Ignore; 8270533b3020ca39898751d4200feed776861dcd1ceNate Begeman assert (Ignore == false && "init list ignored"); 8280533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned NumInitElements = E->getNumInits(); 8290533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8300533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (E->hadArrayRangeDesignator()) 8310533b3020ca39898751d4200feed776861dcd1ceNate Begeman CGF.ErrorUnsupported(E, "GNU array range designator extension"); 8320533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8330533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VType = 8340533b3020ca39898751d4200feed776861dcd1ceNate Begeman dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 8350533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8360533b3020ca39898751d4200feed776861dcd1ceNate Begeman // We have a scalar in braces. Just use the first element. 8370533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VType) 8380533b3020ca39898751d4200feed776861dcd1ceNate Begeman return Visit(E->getInit(0)); 8390533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8400533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned ResElts = VType->getNumElements(); 8410533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8420533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Loop over initializers collecting the Value for each, and remembering 8430533b3020ca39898751d4200feed776861dcd1ceNate Begeman // whether the source was swizzle (ExtVectorElementExpr). This will allow 8440533b3020ca39898751d4200feed776861dcd1ceNate Begeman // us to fold the shuffle for the swizzle into the shuffle for the vector 8450533b3020ca39898751d4200feed776861dcd1ceNate Begeman // initializer, since LLVM optimizers generally do not want to touch 8460533b3020ca39898751d4200feed776861dcd1ceNate Begeman // shuffles. 8470533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned CurIdx = 0; 8480533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool VIsUndefShuffle = false; 8490533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *V = llvm::UndefValue::get(VType); 8500533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned i = 0; i != NumInitElements; ++i) { 8510533b3020ca39898751d4200feed776861dcd1ceNate Begeman Expr *IE = E->getInit(i); 8520533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Init = Visit(IE); 8530533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 8540533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8550533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType()); 8560533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8570533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Handle scalar elements. If the scalar initializer is actually one 8580533b3020ca39898751d4200feed776861dcd1ceNate Begeman // element of a different vector of the same width, use shuffle instead of 8590533b3020ca39898751d4200feed776861dcd1ceNate Begeman // extract+insert. 8600533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VVT) { 8610533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 8620533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init); 8630533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8640533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (EI->getVectorOperandType()->getNumElements() == ResElts) { 8650533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand()); 8660533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *LHS = 0, *RHS = 0; 8670533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) { 8680533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undef -> shuffle (src, undef) 8690533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(C); 8700533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 1; j != ResElts; ++j) 87177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8720533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8730533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = EI->getVectorOperand(); 8740533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = V; 8750533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = true; 8760533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else if (VIsUndefShuffle) { 8770533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undefshuffle && size match -> shuffle (v, src) 8780533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V); 8790533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 88077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty)); 88148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(ResElts + C->getZExtValue())); 8820533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + 1; j != ResElts; ++j) 88377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8840533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8850533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 8860533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = EI->getVectorOperand(); 8870533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8880533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8890533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!Args.empty()) { 890fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 8910533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(LHS, RHS, Mask); 8920533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8930533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8940533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8950533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8960533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 89748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx), 89848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner "vecinit"); 8990533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 9000533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 9010533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 9020533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9030533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9040533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned InitElts = VVT->getNumElements(); 9050533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9060533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's 9070533b3020ca39898751d4200feed776861dcd1ceNate Begeman // input is the same width as the vector being constructed, generate an 9080533b3020ca39898751d4200feed776861dcd1ceNate Begeman // optimized shuffle of the swizzle input into the result. 909a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman unsigned Offset = (CurIdx == 0) ? 0 : ResElts; 9100533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 9110533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init); 9120533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *SVOp = SVI->getOperand(0); 9130533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType()); 9140533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9150533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (OpTy->getNumElements() == ResElts) { 9160533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) { 9170533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the current vector initializer is a shuffle with undef, merge 9180533b3020ca39898751d4200feed776861dcd1ceNate Begeman // this shuffle directly into it. 9190533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) { 9200533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0, 92177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner CGF.Int32Ty)); 9220533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else { 92348431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j)); 9240533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9250533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9260533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0, je = InitElts; j != je; ++j) 92777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty)); 9280533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 92977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9300533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9310533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) 9320533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 9330533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9340533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = SVOp; 9350533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9360533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9370533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9380533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Extend init to result vector length, and then shuffle its contribution 9390533b3020ca39898751d4200feed776861dcd1ceNate Begeman // to the vector initializer into V. 9400533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (Args.empty()) { 9410533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 94248431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j)); 9430533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = InitElts; j != ResElts; ++j) 94477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 945fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 9460533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), 947a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman Mask, "vext"); 9480533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9490533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.clear(); 9500533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 95148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j)); 9520533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 95348431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j+Offset)); 9540533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 95577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9560533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9570533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9580533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If V is undef, make sure it ends up on the RHS of the shuffle to aid 9590533b3020ca39898751d4200feed776861dcd1ceNate Begeman // merging subsequent shuffles into this one. 9600533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) 9610533b3020ca39898751d4200feed776861dcd1ceNate Begeman std::swap(V, Init); 962fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 9630533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit"); 9640533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = isa<llvm::UndefValue>(Init); 9650533b3020ca39898751d4200feed776861dcd1ceNate Begeman CurIdx += InitElts; 9660533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9670533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9680533b3020ca39898751d4200feed776861dcd1ceNate Begeman // FIXME: evaluate codegen vs. shuffling against constant null vector. 9690533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers. 9700533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::Type *EltTy = VType->getElementType(); 9710533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9720533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers 9730533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { 97448431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Value *Idx = Builder.getInt32(CurIdx); 9750533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *Init = llvm::Constant::getNullValue(EltTy); 9760533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 9770533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9780533b3020ca39898751d4200feed776861dcd1ceNate Begeman return V; 9790533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 9800533b3020ca39898751d4200feed776861dcd1ceNate Begeman 981a3697c9c155bda93fd2802f37084b620f4738822Anders Carlssonstatic bool ShouldNullCheckClassCastValue(const CastExpr *CE) { 982a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const Expr *E = CE->getSubExpr(); 98323cba801e11b03929c44f8cf54578305963a3476John McCall 9842de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CE->getCastKind() == CK_UncheckedDerivedToBase) 98523cba801e11b03929c44f8cf54578305963a3476John McCall return false; 986a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 987a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (isa<CXXThisExpr>(E)) { 988a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // We always assume that 'this' is never null. 989a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 990a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 991a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 992a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) { 993906082edf2aea1c6de2926f93a8d7121e49d2a54Sebastian Redl // And that glvalue casts are never null. 9945baba9d98364a3525d6afa15a04cdad82fd6dd30John McCall if (ICE->getValueKind() != VK_RValue) 995a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 996a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 997a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 998a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return true; 999a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson} 1000a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 1001504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 1002504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// have to handle a more broad range of conversions than explicit casts, as they 1003504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// handle things like function to ptr-to-function decay etc. 1004d888962cff03b543fbe9ac6051ec6addf5b993b4Eli FriedmanValue *ScalarExprEmitter::EmitCastExpr(CastExpr *CE) { 1005d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Expr *E = CE->getSubExpr(); 1006592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson QualType DestTy = CE->getType(); 10072de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CastKind Kind = CE->getCastKind(); 1008592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson 1009504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson if (!DestTy->isVoidType()) 1010504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson TestAndClearIgnoreResultAssign(); 1011db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10128c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // Since almost all cast kinds apply to scalars, this switch doesn't have 10138c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // a default case, so the compiler will warn on a missing case. The cases 10148c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // are in the same order as in the CastKind enum. 1015504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson switch (Kind) { 1016daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!"); 1017daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 10182de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_LValueBitCast: 10192de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ObjCObjectLValueCast: { 1020e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor Value *V = EmitLValue(E).getAddress(); 1021e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor V = Builder.CreateBitCast(V, 1022e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor ConvertType(CGF.getContext().getPointerType(DestTy))); 10239f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), DestTy); 1024e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor } 1025e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor 10262de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_AnyPointerToObjCPointerCast: 10272de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_AnyPointerToBlockPointerCast: 10282de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BitCast: { 1029cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 1030cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson return Builder.CreateBitCast(Src, ConvertType(DestTy)); 1031cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson } 10322de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NoOp: 10332de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UserDefinedConversion: 1034ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Visit(const_cast<Expr*>(E)); 1035db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10362de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerived: { 1037a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const CXXRecordDecl *DerivedClassDecl = 1038a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson DestTy->getCXXRecordDeclForPointerType(); 1039a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 1040a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl, 1041f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 1042a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson ShouldNullCheckClassCastValue(CE)); 1043a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 10442de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UncheckedDerivedToBase: 10452de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBase: { 1046191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson const RecordType *DerivedClassTy = 1047191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson E->getType()->getAs<PointerType>()->getPointeeType()->getAs<RecordType>(); 1048191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson CXXRecordDecl *DerivedClassDecl = 1049191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1050191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 105134a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, 1052f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 105334a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson ShouldNullCheckClassCastValue(CE)); 1054191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson } 1055575b374fdbfc2c2224fd3047ac11ffc4b8db9ae5Anders Carlsson case CK_Dynamic: { 10568c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman Value *V = Visit(const_cast<Expr*>(E)); 10578c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE); 10588c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman return CGF.EmitDynamicCast(V, DCE); 10598c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman } 1060d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 10612de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ArrayToPointerDecay: { 1062ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(E->getType()->isArrayType() && 1063ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Array to pointer decay must have array source type!"); 1064ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1065ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *V = EmitLValue(E).getAddress(); // Bitfields can't be arrays. 1066ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1067ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Note that VLA pointers are always decayed, so we don't need to do 1068ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // anything here. 1069ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman if (!E->getType()->isVariableArrayType()) { 1070ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 1071ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 1072ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman ->getElementType()) && 1073ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Expected pointer to array"); 1074ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman V = Builder.CreateStructGEP(V, 0, "arraydecay"); 1075ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1076ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1077ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return V; 1078ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 10792de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FunctionToPointerDecay: 1080ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return EmitLValue(E).getAddress(); 1081ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1082404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall case CK_NullToPointer: 1083404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall if (MustVisitNullValue(E)) 1084404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall (void) Visit(E); 1085404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 1086404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall return llvm::ConstantPointerNull::get( 1087404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall cast<llvm::PointerType>(ConvertType(DestTy))); 1088404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 10892de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NullToMemberPointer: { 1090404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall if (MustVisitNullValue(E)) 1091d608cdb7c044365cf4e8764ade1e11e99c176078John McCall (void) Visit(E); 1092d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 10930bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>(); 10940bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 10950bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 1096191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 10972de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerivedMemberPointer: 10982de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBaseMemberPointer: { 1099d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *Src = Visit(E); 1100d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 1101d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // Note that the AST doesn't distinguish between checked and 1102d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // unchecked member pointer conversions, so we always have to 1103d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // implement checked conversions here. This is inefficient when 1104d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // actual control flow may be required in order to perform the 1105d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // check, which it is for data member pointers (but not member 1106d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // function pointers on Itanium and ARM). 11070bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src); 1108d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 11090bab0cdab751248ca389a5592bcb70eac5d39260John McCall 11102bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingRealToComplex: 11112bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingComplexCast: 11122bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralRealToComplex: 11132bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralComplexCast: 1114f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToFloatingComplex: 1115f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToIntegralComplex: 11162de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ConstructorConversion: 111761ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall case CK_ToUnion: 111861ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall llvm_unreachable("scalar cast to non-scalar value"); 11198c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman break; 1120f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall 1121f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall case CK_GetObjCProperty: { 1122f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)); 1123da29e091650dc011df5209578d7c049549e5e34bDouglas Gregor assert(E->isGLValue() && E->getObjectKind() == OK_ObjCProperty && 1124f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall "CK_GetObjCProperty for non-lvalue or non-ObjCProperty"); 1125f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall RValue RV = CGF.EmitLoadOfLValue(CGF.EmitLValue(E), E->getType()); 1126f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall return RV.getScalarVal(); 1127f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall } 11281de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall 11290ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall case CK_LValueToRValue: 11300ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)); 1131f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(E->isGLValue() && "lvalue-to-rvalue applied to r-value!"); 11320ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall return Visit(const_cast<Expr*>(E)); 11338c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman 11342de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToPointer: { 11357f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 113689f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 113782debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // First, convert to the correct width so that we control the kind of 113882debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // extension. 113977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 1140575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool InputSigned = E->getType()->isSignedIntegerOrEnumerationType(); 114182debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson llvm::Value* IntResult = 114282debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 114389f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 114482debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy)); 11457f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 11462de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_PointerToIntegral: { 11477f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 114889f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 114989f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar // Handle conversion to bool correctly. 115089f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar if (DestTy->isBooleanType()) 1151db50547fd526329d00fa1fee4e7ac90f2624c6e0Daniel Dunbar return EmitScalarConversion(Src, E->getType(), DestTy); 115289f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 11537f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson return Builder.CreatePtrToInt(Src, ConvertType(DestTy)); 11547f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 11552de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ToVoid: { 11562a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E); 1157ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return 0; 1158ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 11592de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_VectorSplat: { 1160ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman const llvm::Type *DstTy = ConvertType(DestTy); 1161ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *Elt = Visit(const_cast<Expr*>(E)); 1162ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1163ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Insert the element in element zero of an undef vector 1164ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *UnV = llvm::UndefValue::get(DstTy); 116548431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *Idx = Builder.getInt32(0); 1166ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 1167ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1168ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Splat the element across to all elements 1169ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::SmallVector<llvm::Constant*, 16> Args; 1170ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 117148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Constant *Zero = Builder.getInt32(0); 1172ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman for (unsigned i = 0; i < NumElements; i++) 1173daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Args.push_back(Zero); 1174ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1175fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 1176ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 1177ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Yay; 1178ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1179daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 11802de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralCast: 11812de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToFloating: 11822de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingToIntegral: 11832de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingCast: 1184d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return EmitScalarConversion(Visit(E), E->getType(), DestTy); 1185ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1186daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_IntegralToBoolean: 1187daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitIntToBoolConversion(Visit(E)); 1188daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_PointerToBoolean: 1189daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitPointerToBoolConversion(Visit(E)); 1190daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_FloatingToBoolean: 1191daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitFloatToBoolConversion(Visit(E)); 11922de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_MemberPointerToBoolean: { 11930bab0cdab751248ca389a5592bcb70eac5d39260John McCall llvm::Value *MemPtr = Visit(E); 11940bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>(); 11950bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT); 1196e9776247577715ad3a19461769a3488a445a8cbdAnders Carlsson } 1197f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1198f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToReal: 1199f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToReal: 1200b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(E, false, true).first; 1201f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1202f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToBoolean: 1203f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToBoolean: { 1204b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall CodeGenFunction::ComplexPairTy V = CGF.EmitComplexExpr(E); 1205f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1206f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall // TODO: kill this function off, inline appropriate case here 1207f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall return EmitComplexToScalarConversion(V, E->getType(), DestTy); 1208f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall } 1209f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 12100bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 121110b00cfe6422906b223724048b9b2123968d3baaChris Lattner 121261ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall llvm_unreachable("unknown scalar cast"); 121319a1d7c646729eb858b15583e647262a22de3637Chris Lattner return 0; 12147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12163379320c10001d7e1ee5d7e7142c417f797cfe82Chris LattnerValue *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 1217150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::StmtExprEvaluation eval(CGF); 1218150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall return CGF.EmitCompoundStmt(*E->getSubStmt(), !E->getType()->isVoidType()) 1219150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall .getScalarVal(); 12203379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner} 12213379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 1222a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike StumpValue *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 1223a5bcb8fec45d127501cd70fe1654b5a08a8aeb35John McCall LValue LV = CGF.EmitBlockDeclRefLValue(E); 1224a5bcb8fec45d127501cd70fe1654b5a08a8aeb35John McCall return CGF.EmitLoadOfLValue(LV, E->getType()).getScalarVal(); 12254e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump} 12263379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 12277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Unary Operators 12297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12318c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *ScalarExprEmitter:: 1232683564a7a93c952f1fbe573b55c542418d29d859Anton YartsevEmitAddConsiderOverflowBehavior(const UnaryOperator *E, 1233683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *InVal, 1234683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *NextVal, bool IsInc) { 1235683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1236683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Undefined: 1237683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return Builder.CreateNSWAdd(InVal, NextVal, IsInc ? "inc" : "dec"); 1238683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev break; 1239683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Defined: 1240683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return Builder.CreateAdd(InVal, NextVal, IsInc ? "inc" : "dec"); 1241683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev break; 1242683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Trapping: 1243683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOpInfo BinOp; 1244683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.LHS = InVal; 1245683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.RHS = NextVal; 1246683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.Ty = E->getType(); 1247683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.Opcode = BO_Add; 1248683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.E = E; 1249683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return EmitOverflowCheckedBinOp(BinOp); 1250683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev break; 1251683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } 1252683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev assert(false && "Unknown SignedOverflowBehaviorTy"); 1253683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return 0; 1254683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev} 1255683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 12565936e33bf74dd6bf126ceee0f6169a2593d03a69John McCallllvm::Value * 12575936e33bf74dd6bf126ceee0f6169a2593d03a69John McCallScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 12585936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall bool isInc, bool isPre) { 12598c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12605936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall QualType type = E->getSubExpr()->getType(); 12615936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *value = EmitLoadOfLValue(LV, type); 12625936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *input = value; 12635936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 12645936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall int amount = (isInc ? 1 : -1); 12655936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 12665936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Special case of integer increment that we have to check first: bool++. 12675936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Due to promotion rules, we get: 12685936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // bool++ -> bool = bool + 1 12695936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // -> bool = (int)bool + 1 12705936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // -> bool = ((int)bool + 1 != 0) 12715936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // An interesting aspect of this is that increment is always true. 12725936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Decrement does not have this property. 12735936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (isInc && type->isBooleanType()) { 12745936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.getTrue(); 12755936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 12765936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Most common case by far: integer increment. 12775936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isIntegerType()) { 12785936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 12795936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount); 12805936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 1281fa0b409ef81f1f70edfa72857c4e211ff50998d5Eli Friedman // Note that signed integer inc/dec with width less than int can't 1282fa0b409ef81f1f70edfa72857c4e211ff50998d5Eli Friedman // overflow because of promotion rules; we're just eliding a few steps here. 1283575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (type->isSignedIntegerOrEnumerationType() && 1284fa0b409ef81f1f70edfa72857c4e211ff50998d5Eli Friedman value->getType()->getPrimitiveSizeInBits() >= 1285fa0b409ef81f1f70edfa72857c4e211ff50998d5Eli Friedman CGF.CGM.IntTy->getBitWidth()) 12865936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = EmitAddConsiderOverflowBehavior(E, value, amt, isInc); 12875936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall else 12885936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec"); 12898c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12905936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Next most common: pointer increment. 12915936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (const PointerType *ptr = type->getAs<PointerType>()) { 12925936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall QualType type = ptr->getPointeeType(); 12935936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 12945936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // VLA types don't have constant size. 12955936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (type->isVariableArrayType()) { 12965936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *vlaSize = 12975936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall CGF.GetVLASize(CGF.getContext().getAsVariableArrayType(type)); 12985936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = CGF.EmitCastToVoidPtr(value); 12995936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (!isInc) vlaSize = Builder.CreateNSWNeg(vlaSize, "vla.negsize"); 13002cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 13012cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateGEP(value, vlaSize, "vla.inc"); 13022cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 13032cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateInBoundsGEP(value, vlaSize, "vla.inc"); 13045936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateBitCast(value, input->getType()); 13055936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13065936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Arithmetic on function pointers (!) is just +-1. 13075936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isFunctionType()) { 130848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *amt = Builder.getInt32(amount); 13095936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13105936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = CGF.EmitCastToVoidPtr(value); 13112cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 13122cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateGEP(value, amt, "incdec.funcptr"); 13132cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 13142cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateInBoundsGEP(value, amt, "incdec.funcptr"); 13155936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateBitCast(value, input->getType()); 13165936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13175936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // For everything else, we can just do a simple increment. 13188c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 131948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *amt = Builder.getInt32(amount); 13202cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 13212cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateGEP(value, amt, "incdec.ptr"); 13222cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 13232cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateInBoundsGEP(value, amt, "incdec.ptr"); 13248c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 13255936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13265936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Vector increment/decrement. 13275936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isVectorType()) { 13285936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (type->hasIntegerRepresentation()) { 13295936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount); 13305936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 1331d4b9ee3b6ad82843c55909d6499232fce530113eEli Friedman value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec"); 1332683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } else { 13335936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateFAdd( 13345936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value, 13355936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::ConstantFP::get(value->getType(), amount), 1336683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev isInc ? "inc" : "dec"); 1337683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } 1338683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 13395936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Floating point. 13405936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isRealFloatingType()) { 13418c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Add the inc/dec to the real part. 13425936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *amt; 13435936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (value->getType()->isFloatTy()) 13445936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall amt = llvm::ConstantFP::get(VMContext, 13455936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::APFloat(static_cast<float>(amount))); 13465936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall else if (value->getType()->isDoubleTy()) 13475936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall amt = llvm::ConstantFP::get(VMContext, 13485936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::APFloat(static_cast<double>(amount))); 13498c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else { 13505936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::APFloat F(static_cast<float>(amount)); 13518c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool ignored; 13528c11a65c18ae607b7073e1e451264492d2297726Chris Lattner F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 13538c11a65c18ae607b7073e1e451264492d2297726Chris Lattner &ignored); 13545936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall amt = llvm::ConstantFP::get(VMContext, F); 13558c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 13565936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec"); 13575936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13585936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Objective-C pointer types. 13595936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else { 13605936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall const ObjCObjectPointerType *OPT = type->castAs<ObjCObjectPointerType>(); 13615936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = CGF.EmitCastToVoidPtr(value); 13625936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13635936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType()); 13645936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (!isInc) size = -size; 13655936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *sizeValue = 13665936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::ConstantInt::get(CGF.SizeTy, size.getQuantity()); 13675936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13682cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 13692cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateGEP(value, sizeValue, "incdec.objptr"); 13702cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 13712cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateInBoundsGEP(value, sizeValue, "incdec.objptr"); 13725936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateBitCast(value, input->getType()); 13738c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 13748c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13758c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Store the updated result through the lvalue. 13768c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (LV.isBitField()) 13775936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall CGF.EmitStoreThroughBitfieldLValue(RValue::get(value), LV, type, &value); 13788c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else 13795936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall CGF.EmitStoreThroughLValue(RValue::get(value), LV, type); 13808c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13818c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // If this is a postinc, return the value read from memory, otherwise use the 13828c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // updated value. 13835936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall return isPre ? value : input; 13848c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 13858c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13868c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13878c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 13897f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 13909a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Emit unary minus with EmitSub so we handle overflow cases etc. 13919a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOpInfo BinOp; 13924ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.RHS = Visit(E->getSubExpr()); 13934ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner 13944ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner if (BinOp.RHS->getType()->isFPOrFPVectorTy()) 13954ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType()); 13964ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner else 13974ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType()); 13989a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.Ty = E->getType(); 13992de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall BinOp.Opcode = BO_Sub; 14009a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.E = E; 14019a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner return EmitSub(BinOp); 14027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 14057f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 14067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 14077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNot(Op, "neg"); 14087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 14117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Compare operand to zero. 14127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 1413db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 14147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Invert value. 14157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // TODO: Could dynamically modify easy computations here. For example, if 14167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // the operand is an icmp ne, turn into icmp eq. 14177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BoolVal = Builder.CreateNot(BoolVal, "lnot"); 1418db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 14199f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson // ZExt result to the expr type. 14209f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext"); 14217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14230027d2bb24db629a33a71d04a5fb90a14c15a680Eli FriedmanValue *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) { 14240027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Try folding the offsetof to a constant. 14250027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr::EvalResult EvalResult; 14260027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (E->Evaluate(EvalResult, CGF.getContext())) 142748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt(EvalResult.Val.getInt()); 14280027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14290027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Loop over the components of the offsetof to compute the value. 14300027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned n = E->getNumComponents(); 14310027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const llvm::Type* ResultType = ConvertType(E->getType()); 14320027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Result = llvm::Constant::getNullValue(ResultType); 14330027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman QualType CurrentType = E->getTypeSourceInfo()->getType(); 14340027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (unsigned i = 0; i != n; ++i) { 14350027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman OffsetOfExpr::OffsetOfNode ON = E->getComponent(i); 143616fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman llvm::Value *Offset = 0; 14370027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman switch (ON.getKind()) { 14380027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Array: { 14390027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index 14400027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex()); 14410027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr); 1442575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool IdxSigned = IdxExpr->getType()->isSignedIntegerOrEnumerationType(); 14430027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv"); 14440027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14450027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type 14460027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = 14470027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getAsArrayType(CurrentType)->getElementType(); 14480027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14490027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the element size 14500027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType, 14510027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity()); 14520027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14530027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Multiply out to compute the result 14540027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = Builder.CreateMul(Idx, ElemSize); 14550027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14560027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14570027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14580027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Field: { 14590027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldDecl *MemberDecl = ON.getField(); 14600027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 14610027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 14620027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14630027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index of the field in its parent. 14640027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned i = 0; 14650027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // FIXME: It would be nice if we didn't have to loop here! 14660027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (RecordDecl::field_iterator Field = RD->field_begin(), 14670027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldEnd = RD->field_end(); 14680027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Field != FieldEnd; (void)++Field, ++i) { 14690027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (*Field == MemberDecl) 14700027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14710027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14720027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman assert(i < RL.getFieldCount() && "offsetof field in wrong type"); 14730027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14740027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the field 14750027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman int64_t OffsetInt = RL.getFieldOffset(i) / 14760027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 14770027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 14780027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14790027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 14800027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = MemberDecl->getType(); 14810027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14820027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 148316fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 14840027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Identifier: 14856d4e44b462fe9e870a40358522379400ccc6e3c2Eli Friedman llvm_unreachable("dependent __builtin_offsetof"); 148616fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 14870027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Base: { 14880027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (ON.getBase()->isVirtual()) { 14890027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.ErrorUnsupported(E, "virtual base in offsetof"); 14900027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman continue; 14910027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14920027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14930027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 14940027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 14950027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14960027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 14970027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = ON.getBase()->getType(); 14980027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14990027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the base. 15000027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const RecordType *BaseRT = CurrentType->getAs<RecordType>(); 15010027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl()); 1502a14f5979572aa25c03d24750ee4724d2031d4edeAnders Carlsson int64_t OffsetInt = RL.getBaseClassOffsetInBits(BaseRD) / 15030027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 15040027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 15050027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 15060027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15070027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15080027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Result = Builder.CreateAdd(Result, Offset); 15090027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15100027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman return Result; 15118ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor} 15128ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 1513f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne/// VisitUnaryExprOrTypeTraitExpr - Return the size or alignment of the type of 15140518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// argument of the sizeof expression as an integer. 15150518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlValue * 1516f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter CollingbourneScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr( 1517f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne const UnaryExprOrTypeTraitExpr *E) { 15180518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl QualType TypeToSize = E->getTypeOfArgument(); 1519f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne if (E->getKind() == UETT_SizeOf) { 1520db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (const VariableArrayType *VAT = 1521f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.getContext().getAsVariableArrayType(TypeToSize)) { 1522f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isArgumentType()) { 1523f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // sizeof(type) - make sure to emit the VLA size. 1524f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.EmitVLASize(TypeToSize); 15258f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman } else { 15268f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // C99 6.5.3.4p2: If the argument is an expression of type 15278f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // VLA, it is evaluated. 15282a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E->getArgumentExpr()); 1529f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman } 1530db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 153196f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson return CGF.GetVLASize(VAT); 1532b50525ba0e996bc072cdb76152fcfe0bc64bb72aAnders Carlsson } 15335d46315ca3cbbfe0d0f5f65520b618fb05dd4446Anders Carlsson } 1534f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman 1535db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If this isn't sizeof(vla), the result must be constant; use the constant 1536db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // folding logic so we don't have to duplicate it here. 1537f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman Expr::EvalResult Result; 1538f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman E->Evaluate(Result, CGF.getContext()); 153948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt(Result.Val.getInt()); 15407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 15417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 154246f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 154346f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 1544b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (Op->getType()->isAnyComplexType()) { 1545b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If it's an l-value, load through the appropriate subobject l-value. 1546b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Note that we have to ask E because Op might be an l-value that 1547b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // this won't work for, e.g. an Obj-C property. 15487eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (E->isGLValue()) 1549b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitLoadOfLValue(CGF.EmitLValue(E), E->getType()) 1550b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall .getScalarVal(); 1551b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1552b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Otherwise, calculate and project. 1553b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(Op, false, true).first; 1554b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall } 1555b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 155646f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return Visit(Op); 155746f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 1558b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 155946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 156046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 1561b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (Op->getType()->isAnyComplexType()) { 1562b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If it's an l-value, load through the appropriate subobject l-value. 1563b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Note that we have to ask E because Op might be an l-value that 1564b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // this won't work for, e.g. an Obj-C property. 15657eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (Op->isGLValue()) 1566b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitLoadOfLValue(CGF.EmitLValue(E), E->getType()) 1567b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall .getScalarVal(); 1568b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1569b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Otherwise, calculate and project. 1570b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(Op, true, false).second; 1571b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall } 1572db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 15737f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __imag on a scalar returns zero. Emit the subexpr to ensure side 15747f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // effects are evaluated, but not the actual value. 1575b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall CGF.EmitScalarExpr(Op, true); 1576c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson return llvm::Constant::getNullValue(ConvertType(E->getType())); 157746f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 157846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 15797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 15807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Binary Operators 15817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 15827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerBinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 15847f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 15857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BinOpInfo Result; 15867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.LHS = Visit(E->getLHS()); 15877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.RHS = Visit(E->getRHS()); 15881f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Result.Ty = E->getType(); 15899a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner Result.Opcode = E->getOpcode(); 15907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.E = E; 15917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Result; 15927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 15937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15946a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue ScalarExprEmitter::EmitCompoundAssignLValue( 15956a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E, 15966a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), 1597d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result) { 159854d76db0aa7107597cac0b80d8e138a37e6d1de9Benjamin Kramer QualType LHSTy = E->getLHS()->getType(); 15991f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo OpInfo; 16006a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1601ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman if (E->getComputationResultType()->isAnyComplexType()) { 1602db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // This needs to go through the complex expression emitter, but it's a tad 1603db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // complicated to do that... I'm leaving it out for now. (Note that we do 1604db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // actually need the imaginary part of the RHS for multiplication and 1605db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // division.) 1606ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman CGF.ErrorUnsupported(E, "complex compound assignment"); 1607d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = llvm::UndefValue::get(CGF.ConvertType(E->getType())); 16086a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LValue(); 16091f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 16106a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1611cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // Emit the RHS first. __block variables need to have the rhs evaluated 1612cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // first, plus this should improve codegen a little. 1613cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.RHS = Visit(E->getRHS()); 1614cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.Ty = E->getComputationResultType(); 16159a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OpInfo.Opcode = E->getOpcode(); 1616cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.E = E; 1617ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // Load/convert the LHS. 1618b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHSLV = EmitCheckedLValue(E->getLHS()); 1619ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy); 1620ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 1621ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman E->getComputationLHSType()); 16226a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 16231f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Expand the binary operator. 1624d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = (this->*Func)(OpInfo); 16256a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 16268c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Convert the result back to the LHS type. 1627ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 16286a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1629db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Store the result value into the LHS lvalue. Bit-fields are handled 1630db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // specially because the result is altered by the store, i.e., [C99 6.5.16p1] 1631db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // 'An assignment expression has the value of the left operand after the 1632db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // assignment...'. 1633d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHSLV.isBitField()) 1634d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy, 1635d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar &Result); 1636d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 1637ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy); 1638d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 16396a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LHSLV; 16406a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 16416a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 16426a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorValue *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 16436a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 16446a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor bool Ignore = TestAndClearIgnoreResultAssign(); 1645d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *RHS; 1646d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar LValue LHS = EmitCompoundAssignLValue(E, Func, RHS); 1647d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1648d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 16497f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 16507f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 1651d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1652b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 1653b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!CGF.getContext().getLangOptions().CPlusPlus) 1654b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return RHS; 1655b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1656d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 1657119a1c6c4029d30cae7b31a2826aa0ff70d01668John McCall if (LHS.isPropertyRef()) 1658d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1659d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1660d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 1661d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 1662d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1663d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1664d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 1665d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return EmitLoadOfLValue(LHS, E->getType()); 16661f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner} 16671f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 16688023030f76d334355b73d9c675d3870858aaf4fdChris Lattnervoid ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck( 16698023030f76d334355b73d9c675d3870858aaf4fdChris Lattner const BinOpInfo &Ops, 16708023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero, bool isDiv) { 16718023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 16728023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *contBB = 16738023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.createBasicBlock(isDiv ? "div.cont" : "rem.cont", CGF.CurFn); 16748023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16758023030f76d334355b73d9c675d3870858aaf4fdChris Lattner const llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType()); 16768023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16778023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->hasSignedIntegerRepresentation()) { 16788023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *IntMin = 167948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth())); 16808023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL); 16818023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16828023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond1 = Builder.CreateICmpEQ(Ops.RHS, Zero); 16838023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *LHSCmp = Builder.CreateICmpEQ(Ops.LHS, IntMin); 16848023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *RHSCmp = Builder.CreateICmpEQ(Ops.RHS, NegOne); 16858023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond2 = Builder.CreateAnd(LHSCmp, RHSCmp, "and"); 16868023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCondBr(Builder.CreateOr(Cond1, Cond2, "or"), 16878023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 16888023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } else { 16898023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateICmpEQ(Ops.RHS, Zero), 16908023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 16918023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 16928023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 16938023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(contBB); 16948023030f76d334355b73d9c675d3870858aaf4fdChris Lattner} 16951f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 16967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 16978023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 16988023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 16998023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 17008023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 17018023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true); 17028023030f76d334355b73d9c675d3870858aaf4fdChris Lattner else if (Ops.Ty->isRealFloatingType()) { 17038023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", 17048023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.CurFn); 17058023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *DivCont = CGF.createBasicBlock("div.cont", CGF.CurFn); 17068023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero), 17078023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, DivCont); 17088023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 17098023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(DivCont); 17108023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 17118023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 1712f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 17137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 1714f60946222721d9ba3c059563935c17b84703187aDouglas Gregor else if (Ops.Ty->hasUnsignedIntegerRepresentation()) 17157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 17167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 17177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 17187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 17217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Rem in C can't be a floating point type: C99 6.5.5p2. 17228023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 17238023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 17248023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 17258023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 17268023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false); 17278023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 17288023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 172952d6874271829c4f5bb70121fb678c27780ce65aEli Friedman if (Ops.Ty->hasUnsignedIntegerRepresentation()) 17307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 17317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 17327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 17337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17352add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike StumpValue *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 17362add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned IID; 17372add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned OpID = 0; 17385d8b2cf9fd704f6ca5e33525803a65421c0b440eMike Stump 17399a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner switch (Ops.Opcode) { 17402de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 17412de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_AddAssign: 1742035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 1; 1743035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::sadd_with_overflow; 1744035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 17452de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 17462de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_SubAssign: 1747035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 2; 1748035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::ssub_with_overflow; 1749035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 17502de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 17512de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_MulAssign: 1752035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 3; 1753035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::smul_with_overflow; 1754035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1755035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump default: 1756035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump assert(false && "Unsupported operation for overflow detection"); 1757ab4eff620a9ce0ea62cdf29529a66c2c98d116f5Daniel Dunbar IID = 0; 1758035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump } 1759035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID <<= 1; 1760035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID |= 1; 1761035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump 17622add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 17632add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17642add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1); 17652add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17662add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 17672add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 17682add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 17692add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17702add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Branch in case of overflow. 17717f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::BasicBlock *initialBB = Builder.GetInsertBlock(); 177293a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 177393a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn); 17742add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17752add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateCondBr(overflow, overflowBB, continueBB); 17762add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 177793a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner // Handle overflow with llvm.trap. 17787f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall const std::string *handlerName = 17797f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall &CGF.getContext().getLangOptions().OverflowHandler; 17807f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall if (handlerName->empty()) { 17817f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall EmitOverflowBB(overflowBB); 17827f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(continueBB); 17837f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return result; 17847f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall } 17857f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17867f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // If an overflow handler is set, then we want to call it and then use its 17877f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // result, if it returns. 17887f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(overflowBB); 17897f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17907f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Get the overflow handler. 17917f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall const llvm::Type *Int8Ty = llvm::Type::getInt8Ty(VMContext); 179295d318c4c10437db40ca6e15fdf32e04012da58eBenjamin Kramer const llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty }; 17937f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType *handlerTy = 17947f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType::get(CGF.Int64Ty, argTypes, true); 17957f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName); 17967f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17977f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Sign extend the args to 64-bit, so that we can use the same handler for 17987f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // all types of overflow. 17997f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty); 18007f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty); 18017f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18027f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Call the handler with the two arguments, the operation, and the size of 18037f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // the result. 18047f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handlerResult = Builder.CreateCall4(handler, lhs, rhs, 18057f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(OpID), 18067f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())); 18077f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18087f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Truncate the result back to the desired size. 18097f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall handlerResult = Builder.CreateTrunc(handlerResult, opTy); 18107f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.CreateBr(continueBB); 18117f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18122add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(continueBB); 1813bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *phi = Builder.CreatePHI(opTy, 2); 18147f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(result, initialBB); 18157f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(handlerResult, overflowBB); 18167f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18177f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return phi; 18182add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump} 18197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 18207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { 182158f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (!Ops.Ty->isAnyPointerType()) { 1822575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (Ops.Ty->isSignedIntegerOrEnumerationType()) { 1823a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1824a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1825a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "add"); 1826a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1827a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 1828a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1829a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1830a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1831a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1832a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1833f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 183487415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFAdd(Ops.LHS, Ops.RHS, "add"); 1835bf933a0cb628670490c15367b3f5ccb3193354a7Dan Gohman 18367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 18372add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 1838daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 18397f215c12af4c3e7f81b24102a676aabfdb4e1566Chris Lattner // Must have binary (not unary) expr here. Unary pointer decrement doesn't 18409a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 18419a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 18429a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 184314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (Ops.Ty->isPointerType() && 18446217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek Ops.Ty->getAs<PointerType>()->isVariableArrayType()) { 1845daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size 18469a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer addition"); 1847daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 18489a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 18498f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Value *Ptr, *Idx; 18508f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Expr *IdxExp; 18519a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const PointerType *PT = BinOp->getLHS()->getType()->getAs<PointerType>(); 1852db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump const ObjCObjectPointerType *OPT = 18539a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<ObjCObjectPointerType>(); 185414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (PT || OPT) { 18558f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.LHS; 18568f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.RHS; 18579a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getRHS(); 185814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } else { // int + pointer 18599a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner PT = BinOp->getRHS()->getType()->getAs<PointerType>(); 18609a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OPT = BinOp->getRHS()->getType()->getAs<ObjCObjectPointerType>(); 186114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff assert((PT || OPT) && "Invalid add expr"); 18628f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.RHS; 18638f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.LHS; 18649a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getLHS(); 18658f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 18668f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner 18678f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 18685936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (Width < CGF.PointerWidthInBits) { 18698f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // Zero or sign extend the pointer value based on whether the index is 18708f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // signed or not. 187177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *IdxType = CGF.IntPtrTy; 1872575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (IdxExp->getType()->isSignedIntegerOrEnumerationType()) 18738f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 18748f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner else 18758f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 18768f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 187714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType ElementType = PT ? PT->getPointeeType() : OPT->getPointeeType(); 1878db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1879c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = ElementType->getAs<ObjCObjectType>()) { 1880db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 18814a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1882199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext().getTypeSizeInChars(OIT).getQuantity()); 18832a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 18843c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 18852a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 18862a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 18872a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1888db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 18892a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1890db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Explicitly handle GNU void* and function pointer arithmetic extensions. The 1891db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // GNU void* casts amount to no-ops since our void* type is i8*, but this is 1892db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // future proof. 1893b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (ElementType->isVoidType() || ElementType->isFunctionType()) { 18943c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1895b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 18962a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 1897b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1898db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1899db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19002cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 19012cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner return Builder.CreateGEP(Ptr, Idx, "add.ptr"); 1902664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ptr, Idx, "add.ptr"); 19037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { 19062add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump if (!isa<llvm::PointerType>(Ops.LHS->getType())) { 1907575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (Ops.Ty->isSignedIntegerOrEnumerationType()) { 1908a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1909a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1910a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub"); 1911a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1912a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 1913a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1914a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1915a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1916a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1917a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1918f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 191987415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFSub(Ops.LHS, Ops.RHS, "sub"); 19202eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner 19217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 19222add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 19231f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 19249a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Must have binary (not unary) expr here. Unary pointer increment doesn't 19259a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 19269a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 19279a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 19289a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner if (BinOp->getLHS()->getType()->isPointerType() && 19299a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<PointerType>()->isVariableArrayType()) { 1930daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size for 1931daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-int 1932daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the division needs to account for the VLA size for 1933daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-ptr. 19349a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer subtraction"); 1935daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 1936daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 19379a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const QualType LHSType = BinOp->getLHS()->getType(); 193814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType LHSElementType = LHSType->getPointeeType(); 19398c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar if (!isa<llvm::PointerType>(Ops.RHS->getType())) { 19408c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - int 19418c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *Idx = Ops.RHS; 19428c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 19435936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (Width < CGF.PointerWidthInBits) { 19448c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Zero or sign extend the pointer value based on whether the index is 19458c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // signed or not. 194677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *IdxType = CGF.IntPtrTy; 1947575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (BinOp->getRHS()->getType()->isSignedIntegerOrEnumerationType()) 19488c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 19498c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar else 19508c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 19518c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 19528c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateNeg(Idx, "sub.ptr.neg"); 1953b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar 1954db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1955c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = LHSElementType->getAs<ObjCObjectType>()) { 1956db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 19574a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1958199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext(). 1959199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getTypeSizeInChars(OIT).getQuantity()); 19602a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 19613c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 19622a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 19632a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr"); 19642a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1965db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 19662a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1967b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // Explicitly handle GNU void* and function pointer arithmetic 1968db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // extensions. The GNU void* casts amount to no-ops since our void* type is 1969db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // i8*, but this is future proof. 1970b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 19713c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1972b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1973b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr"); 1974b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1975db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1976db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19772cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 19782cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner return Builder.CreateGEP(Ops.LHS, Idx, "sub.ptr"); 1979664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ops.LHS, Idx, "sub.ptr"); 19802cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner } 19812cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner 19822cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // pointer - pointer 19832cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner Value *LHS = Ops.LHS; 19842cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner Value *RHS = Ops.RHS; 1985db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19862cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner CharUnits ElementSize; 1987df1109434abd465a4db2e6f69ec2688866660367Dan Gohman 19882cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // Handle GCC extension for pointer arithmetic on void* and function pointer 19892cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // types. 19902cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) 19912cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner ElementSize = CharUnits::One(); 19922cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 19932cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner ElementSize = CGF.getContext().getTypeSizeInChars(LHSElementType); 19942cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner 19952cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner const llvm::Type *ResultType = ConvertType(Ops.Ty); 19962cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); 19972cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 19982cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 19992cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner 20002cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // Optimize out the shift for element size of 1. 20012cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (ElementSize.isOne()) 20022cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner return BytesBetween; 20032cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner 20042cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 20052cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // pointer difference in C is only defined in the case where both operands 20062cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // are pointing to elements of an array. 20072cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner Value *BytesPerElt = 20082cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner llvm::ConstantInt::get(ResultType, ElementSize.getQuantity()); 20092cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner return Builder.CreateExactSDiv(BytesBetween, BytesPerElt, "sub.ptr.div"); 20107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 20127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 20137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 20147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 20157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 20167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 20177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 2018db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2019be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 2020be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 2021be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 2022be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 2023be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 2024be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 202515037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 2026be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 2027be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 2028be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 20297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateShl(Ops.LHS, RHS, "shl"); 20307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 20327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 20337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 20347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 20357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 20367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 20377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 2038db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2039be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 2040be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 2041be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 2042be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 2043be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 2044be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 204515037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 2046be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 2047be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 2048be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 2049f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasUnsignedIntegerRepresentation()) 20507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 20517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 20527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2054aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsevenum IntrinsicType { VCMPEQ, VCMPGT }; 2055aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev// return corresponding comparison intrinsic for given vector type 2056aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsevstatic llvm::Intrinsic::ID GetIntrinsic(IntrinsicType IT, 2057aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev BuiltinType::Kind ElemKind) { 2058aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev switch (ElemKind) { 2059aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev default: assert(0 && "unexpected element type"); 2060aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Char_U: 2061aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UChar: 2062aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 2063aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtub_p; 2064aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2065aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Char_S: 2066aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::SChar: 2067aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 2068aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsb_p; 2069aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2070aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UShort: 2071aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 2072aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtuh_p; 2073aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2074aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Short: 2075aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 2076aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsh_p; 2077aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2078aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UInt: 2079aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::ULong: 2080aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 2081aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtuw_p; 2082aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2083aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Int: 2084aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Long: 2085aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 2086aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsw_p; 2087aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2088aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Float: 2089aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p : 2090aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtfp_p; 2091aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2092aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2093aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return llvm::Intrinsic::not_intrinsic; 2094aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev} 2095aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 20967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 20977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc) { 20987f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 20994f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *Result; 21007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner QualType LHSTy = E->getLHS()->getType(); 21010bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) { 21022de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_EQ || 21032de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall E->getOpcode() == BO_NE); 2104d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *LHS = CGF.EmitScalarExpr(E->getLHS()); 2105d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *RHS = CGF.EmitScalarExpr(E->getRHS()); 21060bab0cdab751248ca389a5592bcb70eac5d39260John McCall Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison( 21072de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE); 2108b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else if (!LHSTy->isAnyComplexType()) { 21097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS = Visit(E->getLHS()); 21107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 2111db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2112aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // If AltiVec, the comparison results in a numeric type, so we use 2113aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // intrinsics comparing vectors and giving 0 or 1 as a result 21146305f721247f13707d9858b17d5696c1e3428a78Anton Yartsev if (LHSTy->isVectorType() && !E->getType()->isVectorType()) { 2115aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // constants for mapping CR6 register bits to predicate result 2116aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6; 2117aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2118aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ID ID = llvm::Intrinsic::not_intrinsic; 2119aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2120aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // in several cases vector arguments order will be reversed 2121aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Value *FirstVecArg = LHS, 2122aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev *SecondVecArg = RHS; 2123aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2124aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev QualType ElTy = LHSTy->getAs<VectorType>()->getElementType(); 2125f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const BuiltinType *BTy = ElTy->getAs<BuiltinType>(); 2126aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev BuiltinType::Kind ElementKind = BTy->getKind(); 2127aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2128aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev switch(E->getOpcode()) { 2129aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev default: assert(0 && "is not a comparison operation"); 2130aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_EQ: 2131aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2132aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPEQ, ElementKind); 2133aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2134aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_NE: 2135aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2136aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPEQ, ElementKind); 2137aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2138aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_LT: 2139aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2140aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2141aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2142aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2143aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_GT: 2144aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2145aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2146aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2147aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_LE: 2148aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (ElementKind == BuiltinType::Float) { 2149aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2150aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 2151aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2152aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2153aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev else { 2154aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2155aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2156aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2157aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2158aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_GE: 2159aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (ElementKind == BuiltinType::Float) { 2160aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2161aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 2162aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2163aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev else { 2164aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2165aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2166aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2167aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2168aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2169aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2170aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 217148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Value *CR6Param = Builder.getInt32(CR6); 2172aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Function *F = CGF.CGM.getIntrinsic(ID); 2173aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Result = Builder.CreateCall3(F, CR6Param, FirstVecArg, SecondVecArg, ""); 2174aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 2175aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2176aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2177f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (LHS->getType()->isFPOrFPVectorTy()) { 21787a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 21797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 2180f60946222721d9ba3c059563935c17b84703187aDouglas Gregor } else if (LHSTy->hasSignedIntegerRepresentation()) { 2181ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 21827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 21837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 2184ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman // Unsigned integers and pointers. 2185ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 21867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 21877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 21889c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner 21899c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // If this is a vector comparison, sign extend the result to the appropriate 21909c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // vector integer type and return it (don't convert to bool). 21919c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner if (LHSTy->isVectorType()) 21929c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 2193db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 21957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex Comparison: can only be an equality comparison. 21967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 21977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 2198db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2199183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType CETy = LHSTy->getAs<ComplexType>()->getElementType(); 2200db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22014f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *ResultR, *ResultI; 22027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (CETy->isRealFloatingType()) { 22037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 22047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 22057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 22067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 22077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 22087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex comparisons can only be equality comparisons. As such, signed 22097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // and unsigned opcodes are the same. 22107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 22117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 22127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 22137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 22147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2215db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22162de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (E->getOpcode() == BO_EQ) { 22177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 22187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 22192de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_NE && 22207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Complex comparison other than == or != ?"); 22217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 22227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 22237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 222432f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes 222532f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 22267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 22277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 22287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 22297f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool Ignore = TestAndClearIgnoreResultAssign(); 22307f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 22317f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __block variables need to have the rhs evaluated first, plus this should 22327f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // improve codegen just a little. 22337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 2234b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHS = EmitCheckedLValue(E->getLHS()); 2235db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2236ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar // Store the value into the LHS. Bit-fields are handled specially 2237371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // because the result is altered by the store, i.e., [C99 6.5.16p1] 2238371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // 'An assignment expression has the value of the left operand after 2239daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // the assignment...'. 2240d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHS.isBitField()) 2241d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType(), 2242d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar &RHS); 2243d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 2244ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType()); 2245d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2246d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 22477f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 22487f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 2249d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2250b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 2251b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!CGF.getContext().getLangOptions().CPlusPlus) 2252b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return RHS; 2253b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 2254d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 2255119a1c6c4029d30cae7b31a2826aa0ff70d01668John McCall if (LHS.isPropertyRef()) 2256d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2257d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2258d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 2259d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 2260d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2261d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2262d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 22637f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitLoadOfLValue(LHS, E->getType()); 22647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 22657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 22667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 22677804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 22687804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 226920eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 227020eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 && X, just emit X without inserting the control flow. 2271c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool LHSCondVal; 2272c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) { 2273c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (LHSCondVal) { // If we have 1 && X, just emit X. 22740946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 22757804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 22767804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 22770946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2278db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22797804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 228020eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 22817804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::Constant::getNullValue(ResTy); 22820946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2283db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22849615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 22859615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 228620eb09d562b80420a3328be789547af354bf3e36Chris Lattner 2287150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 2288150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2289f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is false, go to the failure (cont) block. 2290f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 2291f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2292f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2293f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be false. Start 2294f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 2295bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2, 22960032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2297f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2298f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 22993b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 2300db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2301150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 23027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 23037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2304150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2305db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 23077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2308f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2309f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2310f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 2311acd723666777b4ac1f79a97b6a300e6cf919d519Devang Patel if (CGF.getDebugInfo()) 2312acd723666777b4ac1f79a97b6a300e6cf919d519Devang Patel // There is no need to emit line number for unconditional branch. 2313acd723666777b4ac1f79a97b6a300e6cf919d519Devang Patel Builder.SetCurrentDebugLocation(llvm::DebugLoc()); 23147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 23157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2316db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 23187804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 23197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 23227804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 23237804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 232420eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 232520eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 || X, just emit X without inserting the control flow. 2326c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool LHSCondVal; 2327c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) { 2328c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (!LHSCondVal) { // If we have 0 || X, just emit X. 23290946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 23307804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 23317804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 23320946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2333db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23347804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 233520eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 23367804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::ConstantInt::get(ResTy, 1); 23370946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2338db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23399615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 23409615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 2341db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2342150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 2343150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2344f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is true, go to the success (cont) block. 2345f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 2346f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2347f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2348f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be true. Start 2349f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 2350bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2, 23510032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2352f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2353f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 23543b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 2355f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2356150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 235733da07db112f4877f6ab13e20db08b9bb86a0c2eAnders Carlsson 2358f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit the RHS condition as a bool value. 23597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 23607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2361db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2362150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2363db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 23657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2366db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2367f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2368f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 2369f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBlock(ContBlock); 23707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2371db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 23737804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 23747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 23772a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E->getLHS()); 2378a448fb2da03ece39978784793eea68760e8205a1Daniel Dunbar CGF.EnsureInsertPoint(); 23797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getRHS()); 23807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 23837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Other Operators 23847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 23857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23869802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 23879802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// expression is cheap enough and side-effect-free enough to evaluate 23889802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// unconditionally instead of conditionally. This is used to convert control 23899802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// flow into selects in some cases. 2390df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stumpstatic bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 2391df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CodeGenFunction &CGF) { 2392f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne E = E->IgnoreParens(); 2393db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2394c6bea67efc38b075c401ebdb6ae97afa08cbb51dChris Lattner // Anything that is an integer or floating point constant is fine. 2395c6bea67efc38b075c401ebdb6ae97afa08cbb51dChris Lattner if (E->isConstantInitializer(CGF.getContext(), false)) 23969802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2397db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23989802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // Non-volatile automatic variables too, to get "cond ? X : Y" where 23999802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // X and Y are local variables. 24009802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 24019802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 2402df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (VD->hasLocalStorage() && !(CGF.getContext() 2403df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .getCanonicalType(VD->getType()) 2404df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .isVolatileQualified())) 24059802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2406db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24079802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return false; 24089802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner} 24099802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 24109802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 24117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter:: 241256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallVisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 24137f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 241456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 241556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // Bind the common expression if necessary. 241656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall CodeGenFunction::OpaqueValueMapping binding(CGF, E); 241756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 241856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *condExpr = E->getCond(); 241956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *lhsExpr = E->getTrueExpr(); 242056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *rhsExpr = E->getFalseExpr(); 242156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 242231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the condition constant folds and can be elided, try to avoid emitting 242331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the condition and the dead arm. 2424c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool CondExprBool; 2425c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) { 242656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *live = lhsExpr, *dead = rhsExpr; 2427c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (!CondExprBool) std::swap(live, dead); 2428db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 242931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the dead side doesn't have labels we need, and if the Live side isn't 243031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the gnu missing ?: extension (which we could handle, but don't bother 243131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // to), just emit the Live part. 243256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!CGF.ContainsLabel(dead)) 243356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return Visit(live); 2434c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner } 2435db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24366155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // OpenCL: If the condition is a vector, we can treat this condition like 24376155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // the select function. 24386155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (CGF.getContext().getLangOptions().OpenCL 243956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall && condExpr->getType()->isVectorType()) { 244056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *CondV = CGF.EmitScalarExpr(condExpr); 244156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *LHS = Visit(lhsExpr); 244256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *RHS = Visit(rhsExpr); 24436155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 244456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall const llvm::Type *condType = ConvertType(condExpr->getType()); 24456155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::VectorType *vecTy = cast<llvm::VectorType>(condType); 24466155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24476155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman unsigned numElem = vecTy->getNumElements(); 24486155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::Type *elemType = vecTy->getElementType(); 24496155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24506155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman std::vector<llvm::Constant*> Zvals; 24516155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman for (unsigned i = 0; i < numElem; ++i) 245248431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Zvals.push_back(llvm::ConstantInt::get(elemType, 0)); 24536155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24546155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *zeroVec = llvm::ConstantVector::get(Zvals); 24556155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec); 24566155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp = Builder.CreateSExt(TestMSB, 24576155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::VectorType::get(elemType, 24586155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman numElem), 24596155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman "sext"); 24606155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp2 = Builder.CreateNot(tmp); 24616155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24626155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // Cast float to int to perform ANDs if necessary. 24636155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *RHSTmp = RHS; 24646155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *LHSTmp = LHS; 24656155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman bool wasCast = false; 24666155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType()); 24676155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (rhsVTy->getElementType()->isFloatTy()) { 24686155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType()); 24696155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman LHSTmp = Builder.CreateBitCast(LHS, tmp->getType()); 24706155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman wasCast = true; 24716155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 24726155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24736155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2); 24746155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp); 24756155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond"); 24766155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (wasCast) 24776155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman tmp5 = Builder.CreateBitCast(tmp5, RHS->getType()); 2478db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24796155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman return tmp5; 24806155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 24816155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24829802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // If this is a really simple expression (like x ? 4 : 5), emit this as a 24839802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // select instead of as control flow. We can only do this if it is cheap and 2484531a550531c144a58438f187816abbf1879e1c4eChris Lattner // safe to evaluate the LHS and RHS unconditionally. 248556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (isCheapEnoughToEvaluateUnconditionally(lhsExpr, CGF) && 248656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall isCheapEnoughToEvaluateUnconditionally(rhsExpr, CGF)) { 248756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr); 248856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *LHS = Visit(lhsExpr); 248956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *RHS = Visit(rhsExpr); 24909802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 24919802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner } 2492db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2493be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 2494be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 24959615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 2496150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2497150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 249856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock); 2499fb6fa30a9b06670deb14f862dddbc49a12552939Anders Carlsson 25007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(LHSBlock); 2501150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 250256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Value *LHS = Visit(lhsExpr); 2503150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2504db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHSBlock = Builder.GetInsertBlock(); 2506150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall Builder.CreateBr(ContBlock); 2507db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 2509150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 251056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Value *RHS = Visit(rhsExpr); 2511150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2512db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2513150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall RHSBlock = Builder.GetInsertBlock(); 25147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 2515db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 251648daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman // If the LHS or RHS is a throw expression, it will be legitimately null. 251748daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!LHS) 251848daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return RHS; 251948daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!RHS) 252048daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return LHS; 2521db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Create a PHI node for the real part. 2523bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond"); 25247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(LHS, LHSBlock); 25257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHS, RHSBlock); 25267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return PN; 25277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 25287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 25297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 25307976932a1c256d447316ffac58e9821417725e34Eli Friedman return Visit(E->getChosenSubExpr(CGF.getContext())); 25317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 25327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 25332202bce80fc72d067cbe67dc1512f7b45351fd31Chris LattnerValue *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 25344fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 2535ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 2536ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 2537ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson // If EmitVAArg fails, we fall back to the LLVM instruction. 2538db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (!ArgPtr) 2539ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 2540ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 25417f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // FIXME Volatility. 2542ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateLoad(ArgPtr); 25437c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson} 25447c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 25456b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCallValue *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *block) { 25466b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall return CGF.EmitBlockLiteral(block); 2547df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump} 2548df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 254961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya LattnerValue *ScalarExprEmitter::VisitAsTypeExpr(AsTypeExpr *E) { 255061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Value *Src = CGF.EmitScalarExpr(E->getSrcExpr()); 255161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner const llvm::Type * DstTy = ConvertType(E->getDstType()); 255261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 255361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // Going from vec4->vec3 or vec3->vec4 is a special case and requires 255461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // a shuffle vector instead of a bitcast. 255561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner const llvm::Type *SrcTy = Src->getType(); 255661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if (isa<llvm::VectorType>(DstTy) && isa<llvm::VectorType>(SrcTy)) { 255761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner unsigned numElementsDst = cast<llvm::VectorType>(DstTy)->getNumElements(); 255861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner unsigned numElementsSrc = cast<llvm::VectorType>(SrcTy)->getNumElements(); 255961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if ((numElementsDst == 3 && numElementsSrc == 4) 256061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner || (numElementsDst == 4 && numElementsSrc == 3)) { 256161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 256261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 256361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // In the case of going from int4->float3, a bitcast is needed before 256461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // doing a shuffle. 256561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner const llvm::Type *srcElemTy = 256661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner cast<llvm::VectorType>(SrcTy)->getElementType(); 256761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner const llvm::Type *dstElemTy = 256861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner cast<llvm::VectorType>(DstTy)->getElementType(); 256961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 257061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if ((srcElemTy->isIntegerTy() && dstElemTy->isFloatTy()) 257161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner || (srcElemTy->isFloatTy() && dstElemTy->isIntegerTy())) { 257261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // Create a float type of the same size as the source or destination. 257361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner const llvm::VectorType *newSrcTy = llvm::VectorType::get(dstElemTy, 257461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner numElementsSrc); 257561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 257661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Src = Builder.CreateBitCast(Src, newSrcTy, "astypeCast"); 257761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner } 257861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 257961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner llvm::Value *UnV = llvm::UndefValue::get(Src->getType()); 258061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 258161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner llvm::SmallVector<llvm::Constant*, 3> Args; 258261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(Builder.getInt32(0)); 258361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(Builder.getInt32(1)); 258461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(Builder.getInt32(2)); 258561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 258661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if (numElementsDst == 4) 258761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(llvm::UndefValue::get( 258861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner llvm::Type::getInt32Ty(CGF.getLLVMContext()))); 258961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 259061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 259161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 259261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner return Builder.CreateShuffleVector(Src, UnV, Mask, "astype"); 259361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner } 259461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner } 259561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 259661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner return Builder.CreateBitCast(Src, DstTy, "astype"); 259761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner} 259861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 25997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 26007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Entry Point into this File 26017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 26027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2603db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitScalarExpr - Emit the computation of the specified expression of scalar 2604db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type, ignoring the result. 26057f79f9be5916c51c35da4f126b7c12596a101607Mike StumpValue *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 26067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E && !hasAggregateLLVMType(E->getType()) && 26077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Invalid scalar expression to emit"); 2608db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 26095de7a0e8800b89780e565c1013e566414f11546aDevang Patel if (isa<CXXDefaultArgExpr>(E)) 2610aa11289f754d220c9c155b68a4f84cdcfcefef6aDevang Patel disableDebugInfo(); 26115de7a0e8800b89780e565c1013e566414f11546aDevang Patel Value *V = ScalarExprEmitter(*this, IgnoreResultAssign) 26127f79f9be5916c51c35da4f126b7c12596a101607Mike Stump .Visit(const_cast<Expr*>(E)); 26135de7a0e8800b89780e565c1013e566414f11546aDevang Patel if (isa<CXXDefaultArgExpr>(E)) 2614aa11289f754d220c9c155b68a4f84cdcfcefef6aDevang Patel enableDebugInfo(); 26155de7a0e8800b89780e565c1013e566414f11546aDevang Patel return V; 26167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 26173707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 26183707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 26193707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 26204f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 26214f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 26223707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 26233707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner "Invalid scalar expression to emit"); 26243707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 26253707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 26264f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 2627db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 2628db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 2629db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 26304f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 26314f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, 26324f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 26339b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 26344f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner "Invalid complex -> scalar conversion"); 26354f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 26364f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner DstTy); 26374f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 2638cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 26398c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 26408c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *CodeGenFunction:: 26418c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 26428c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 26438c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre); 26448c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 26458c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2646820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz JahanianLValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 2647820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian llvm::Value *V; 2648820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // object->isa or (*object).isa 2649820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // Generate code as for: *(Class*)object 26505ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian // build Class* type 26515ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian const llvm::Type *ClassPtrTy = ConvertType(E->getType()); 26525ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian 2653820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Expr *BaseExpr = E->getBase(); 26547eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (BaseExpr->isRValue()) { 26555ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = CreateTempAlloca(ClassPtrTy, "resval"); 26565ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian llvm::Value *Src = EmitScalarExpr(BaseExpr); 26575ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian Builder.CreateStore(Src, V); 26589f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue( 26599f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar MakeAddrLValue(V, E->getType()), E->getType()); 26609f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar } else { 26619f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar if (E->isArrow()) 26629f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr); 26639f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar else 26649f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = EmitLValue(BaseExpr).getAddress(); 26655ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 2666820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 2667820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // build Class* type 2668820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian ClassPtrTy = ClassPtrTy->getPointerTo(); 2669820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian V = Builder.CreateBitCast(V, ClassPtrTy); 26709f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(V, E->getType()); 2671820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian} 2672820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 26736a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 26742a41637a995affa1563f4d82a8b026e326a2faa0John McCallLValue CodeGenFunction::EmitCompoundAssignmentLValue( 26756a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E) { 26766a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor ScalarExprEmitter Scalar(*this); 2677d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *Result = 0; 26786a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor switch (E->getOpcode()) { 26796a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#define COMPOUND_OP(Op) \ 26802de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_##Op##Assign: \ 26816a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 2682d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result) 26836a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Mul); 26846a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Div); 26856a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Rem); 26866a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Add); 26876a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Sub); 26886a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shl); 26896a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shr); 26906a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(And); 26916a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Xor); 26926a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Or); 26936a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#undef COMPOUND_OP 26946a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 26952de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemD: 26962de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemI: 26972de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 26982de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Div: 26992de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Rem: 27002de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 27012de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 27022de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shl: 27032de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shr: 27042de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LT: 27052de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GT: 27062de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LE: 27072de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GE: 27082de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_EQ: 27092de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_NE: 27102de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_And: 27112de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Xor: 27122de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Or: 27132de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LAnd: 27142de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LOr: 27152de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Assign: 27162de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Comma: 27176a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor assert(false && "Not valid compound assignment operators"); 27186a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor break; 27196a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor } 27206a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 27216a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor llvm_unreachable("Unhandled compound assignment operator"); 27226a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 2723