CGExprScalar.cpp revision 9cbe4f0ba01ec304e1e3d071c071f7bca33631c0
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 85545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall Value *EmitLoadOfLValue(LValue LV) { 86545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return CGF.EmitLoadOfLValue(LV).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) { 93545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return EmitLoadOfLValue(EmitCheckedLValue(E)); 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()) 200545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E)); 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); 255545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall Value *V = CGF.EmitLoadOfLValue(LV).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 } 272bc8d40d85f3fa1e34569834916f18fecaa635152John McCall Value *VisitExplicitCastExpr(ExplicitCastExpr *E) { 273745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (E->getType()->isVariablyModifiedType()) 274bc8d40d85f3fa1e34569834916f18fecaa635152John McCall CGF.EmitVariablyModifiedType(E->getType()); 275bc8d40d85f3fa1e34569834916f18fecaa635152John McCall return VisitCastExpr(E); 2767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 277bc8d40d85f3fa1e34569834916f18fecaa635152John McCall Value *VisitCastExpr(CastExpr *E); 2787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCallExpr(const CallExpr *E) { 280e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson if (E->getCallReturnType()->isReferenceType()) 281e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson return EmitLoadOfLValue(E); 282db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2839b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitCallExpr(E).getScalarVal(); 2847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2858f2926b73ed635afecd020da787af6a837601a2bDaniel Dunbar 2863379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner Value *VisitStmtExpr(const StmtExpr *E); 2874e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump 288a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike Stump Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E); 289db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Unary Operators. 2917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostDec(const UnaryOperator *E) { 2928c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2938c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, false); 2947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostInc(const UnaryOperator *E) { 2968c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2978c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, false); 2987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreDec(const UnaryOperator *E) { 3008c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 3018c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, true); 3027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreInc(const UnaryOperator *E) { 3048c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 3058c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, true); 3067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3078c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 308683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *EmitAddConsiderOverflowBehavior(const UnaryOperator *E, 309683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *InVal, 310683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *NextVal, 311683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev bool IsInc); 312683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 3138c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 3148c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre); 3158c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 3168c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 3177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryAddrOf(const UnaryOperator *E) { 3185808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall if (isa<MemberPointerType>(E->getType())) // never sugared 3195808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall return CGF.CGM.getMemberPointerConstant(E); 3205808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall 3217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLValue(E->getSubExpr()).getAddress(); 3227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 323fd569004b78124c1041feee75a1e311166268c8dJohn McCall Value *VisitUnaryDeref(const UnaryOperator *E) { 324fd569004b78124c1041feee75a1e311166268c8dJohn McCall if (E->getType()->isVoidType()) 325fd569004b78124c1041feee75a1e311166268c8dJohn McCall return Visit(E->getSubExpr()); // the actual value should be unused 326fd569004b78124c1041feee75a1e311166268c8dJohn McCall return EmitLoadOfLValue(E); 327fd569004b78124c1041feee75a1e311166268c8dJohn McCall } 3287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPlus(const UnaryOperator *E) { 3297f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // This differs from gcc, though, most likely due to a bug in gcc. 3307f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 3317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 3327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryMinus (const UnaryOperator *E); 3347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryNot (const UnaryOperator *E); 3357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryLNot (const UnaryOperator *E); 33646f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryReal (const UnaryOperator *E); 33746f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryImag (const UnaryOperator *E); 3387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryExtension(const UnaryOperator *E) { 3397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 3407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3418ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 3425f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson // C++ 34304421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 34404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 34504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 3465f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson Value *VisitCXXThisExpr(CXXThisExpr *TE) { 3475f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson return CGF.LoadCXXThis(); 348db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 349db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3504765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall Value *VisitExprWithCleanups(ExprWithCleanups *E) { 3514765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall return CGF.EmitExprWithCleanups(E).getScalarVal(); 3527f6ad153565245026c7569314f65a4d4ff4ac41fAnders Carlsson } 353a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson Value *VisitCXXNewExpr(const CXXNewExpr *E) { 354a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson return CGF.EmitCXXNewExpr(E); 355a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson } 35660e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) { 35760e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson CGF.EmitCXXDeleteExpr(E); 35860e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson return 0; 35960e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson } 3609dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman Value *VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 36148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt1(E->getValue()); 3629dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman } 363db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3646ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet Value *VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *E) { 365f187237d916afa97c491ac32fe98be7d335c5b63Francois Pichet return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 3666ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet } 3676ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet 36821ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley Value *VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) { 36921ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue()); 37021ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley } 37121ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley 372552622067dc45013d240f73952fece703f5e63bdJohn Wiegley Value *VisitExpressionTraitExpr(const ExpressionTraitExpr *E) { 373552622067dc45013d240f73952fece703f5e63bdJohn Wiegley return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue()); 374552622067dc45013d240f73952fece703f5e63bdJohn Wiegley } 375552622067dc45013d240f73952fece703f5e63bdJohn Wiegley 376a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) { 377a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // C++ [expr.pseudo]p1: 378db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // The result shall only be used as the operand for the function call 379a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // operator (), and the result of such a call has type void. The only 380a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // effect is the evaluation of the postfix-expression before the dot or 381a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // arrow. 382a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor CGF.EmitScalarExpr(E->getBase()); 383a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor return 0; 384a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor } 385db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 386c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 387a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 388c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson } 389756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 390756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson Value *VisitCXXThrowExpr(const CXXThrowExpr *E) { 391756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson CGF.EmitCXXThrowExpr(E); 392756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson return 0; 393756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson } 394756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 39598294def01c97e127fa6d812ebd944d37212828aSebastian Redl Value *VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) { 39648431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt1(E->getValue()); 39798294def01c97e127fa6d812ebd944d37212828aSebastian Redl } 39898294def01c97e127fa6d812ebd944d37212828aSebastian Redl 3997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Binary Operators. 4007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitMul(const BinOpInfo &Ops) { 401575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (Ops.Ty->isSignedIntegerOrEnumerationType()) { 402a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 403a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 404a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul"); 405a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 406a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 407a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 408a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 409a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 410a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 411a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 412f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 41387415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul"); 4147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 4157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4168023030f76d334355b73d9c675d3870858aaf4fdChris Lattner bool isTrapvOverflowBehavior() { 4178023030f76d334355b73d9c675d3870858aaf4fdChris Lattner return CGF.getContext().getLangOptions().getSignedOverflowBehavior() 4188023030f76d334355b73d9c675d3870858aaf4fdChris Lattner == LangOptions::SOB_Trapping; 4198023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 4202add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Create a binary op that checks for overflow. 4212add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Currently only supports +, - and *. 4222add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); 4238023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Emit the overflow BB when -ftrapv option is activated. 4248023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitOverflowBB(llvm::BasicBlock *overflowBB) { 4258023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(overflowBB); 4268023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Function *Trap = CGF.CGM.getIntrinsic(llvm::Intrinsic::trap); 4278023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCall(Trap); 4288023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateUnreachable(); 4298023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 4308023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Check for undefined division and modulus behaviors. 4318023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops, 4328023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero,bool isDiv); 4337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitDiv(const BinOpInfo &Ops); 4347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitRem(const BinOpInfo &Ops); 4357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAdd(const BinOpInfo &Ops); 4367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitSub(const BinOpInfo &Ops); 4377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShl(const BinOpInfo &Ops); 4387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShr(const BinOpInfo &Ops); 4397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAnd(const BinOpInfo &Ops) { 4407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 4417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitXor(const BinOpInfo &Ops) { 4437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 4447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitOr (const BinOpInfo &Ops) { 4467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 4477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4491f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo EmitBinOps(const BinaryOperator *E); 4506a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 4516a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*F)(const BinOpInfo &), 452d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result); 4536a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 4543ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *EmitCompoundAssign(const CompoundAssignOperator *E, 4551f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 4561f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 4571f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Binary operators and binary compound assignment operators. 4581f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#define HANDLEBINOP(OP) \ 4593ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP(const BinaryOperator *E) { \ 4603ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return Emit ## OP(EmitBinOps(E)); \ 4613ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner } \ 4623ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 4633ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 4641f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 4657177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Mul) 4667177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Div) 4677177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Rem) 4687177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Add) 4697177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Sub) 4707177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shl) 4717177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shr) 4727177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(And) 4737177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Xor) 4747177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Or) 4751f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#undef HANDLEBINOP 4768c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 4777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Comparisons. 4787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 4797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc); 4807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#define VISITCOMP(CODE, UI, SI, FP) \ 4817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBin##CODE(const BinaryOperator *E) { \ 4827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 4837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::FCmpInst::FP); } 4847177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT) 4857177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT) 4867177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE) 4877177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE) 4887177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ) 4897177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE) 4907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#undef VISITCOMP 491db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinAssign (const BinaryOperator *E); 4937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLAnd (const BinaryOperator *E); 4957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLOr (const BinaryOperator *E); 4967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinComma (const BinaryOperator *E); 4977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 49825b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); } 49925b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); } 50025b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman 5017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Other Operators. 502df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump Value *VisitBlockExpr(const BlockExpr *BE); 50356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Value *VisitAbstractConditionalOperator(const AbstractConditionalOperator *); 5047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitChooseExpr(ChooseExpr *CE); 5057c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson Value *VisitVAArgExpr(VAArgExpr *VE); 5067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 5077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return CGF.EmitObjCStringLiteral(E); 5087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 50961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Value *VisitAsTypeExpr(AsTypeExpr *CE); 5107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 5117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} // end anonymous namespace. 5127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Utilities 5157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5179abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner/// EmitConversionToBool - Convert the specified expression value to a 5183420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner/// boolean (i1) truth value. This is equivalent to "Val != 0". 5199abc84e7ac4db891209fe67cc3a8c9690dc886efChris LattnerValue *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 520467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs"); 521db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 522daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (SrcType->isRealFloatingType()) 523daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitFloatToBoolConversion(Src); 524db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5250bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType)) 5260bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT); 527db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 528d1d66bcd6914ff82abdfa88dd25bb0b74cde3b99Daniel Dunbar assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 5299abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner "Unknown scalar type to convert"); 530db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 531daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (isa<llvm::IntegerType>(Src->getType())) 532daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitIntToBoolConversion(Src); 533db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 534daa8e4e888758d55a7a759dd4a91b83921cef222John McCall assert(isa<llvm::PointerType>(Src->getType())); 535daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitPointerToBoolConversion(Src); 5369abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner} 5379abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 5383707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 5393707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 5404f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 5414f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstType) { 5429619662a1d42e2008b865d3459c0677e149dad1bChris Lattner SrcType = CGF.getContext().getCanonicalType(SrcType); 5439619662a1d42e2008b865d3459c0677e149dad1bChris Lattner DstType = CGF.getContext().getCanonicalType(DstType); 5443707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (SrcType == DstType) return Src; 545db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 546cf289083ab007264fa3ea96d92f133339aee5d2dChris Lattner if (DstType->isVoidType()) return 0; 547db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5483707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 549ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstType->isBooleanType()) 550ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return EmitConversionToBool(Src, SrcType); 551db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5523707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner const llvm::Type *DstTy = ConvertType(DstType); 5533707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 5543707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Ignore conversions like int -> uint. 5553707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (Src->getType() == DstTy) 5563707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Src; 5573707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 558db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle pointer conversions next: pointers can only be converted to/from 559db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // other pointers and integers. Check for pointer types in terms of LLVM, as 560db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // some native types (like Obj-C id) may map to a pointer type. 561270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(DstTy)) { 5623707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // The source value may be an integer, or a pointer. 563191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson if (isa<llvm::PointerType>(Src->getType())) 5643707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Builder.CreateBitCast(Src, DstTy, "conv"); 565191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 5663707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 56725615424741bcce31fe52c896f76268f0307f00dEli Friedman // First, convert to the correct width so that we control the kind of 56825615424741bcce31fe52c896f76268f0307f00dEli Friedman // extension. 56977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 570575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool InputSigned = SrcType->isSignedIntegerOrEnumerationType(); 57125615424741bcce31fe52c896f76268f0307f00dEli Friedman llvm::Value* IntResult = 57225615424741bcce31fe52c896f76268f0307f00dEli Friedman Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 57325615424741bcce31fe52c896f76268f0307f00dEli Friedman // Then, cast to pointer. 57425615424741bcce31fe52c896f76268f0307f00dEli Friedman return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 5753707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 576db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 577270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(Src->getType())) { 5783707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Must be an ptr to int cast. 5793707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 58050b5a30db40322880340e957ad7d6d8d60bb4c5bAnders Carlsson return Builder.CreatePtrToInt(Src, DstTy, "conv"); 5813707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 582db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 583213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // A scalar can be splatted to an extended vector of the same element type 5842ef13e5abef0570a9f567b4671367275c05d4d34Nate Begeman if (DstType->isExtVectorType() && !SrcType->isVectorType()) { 5856fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Cast the scalar to element type 586183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType EltTy = DstType->getAs<ExtVectorType>()->getElementType(); 5876fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 5886fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 5896fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Insert the element in element zero of an undef vector 59003e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::Value *UnV = llvm::UndefValue::get(DstTy); 59148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *Idx = Builder.getInt32(0); 5926fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 5936fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 5946fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Splat the element across to all elements 5956fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 5966fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 597fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner for (unsigned i = 0; i != NumElements; ++i) 59848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(0)); 599db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 600fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 6016fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 6026fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman return Yay; 6036fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman } 6044119d1aeca8016654d381ce079864058d1709571Nate Begeman 6053b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner // Allow bitcast from vector to integer/fp of the same size. 6067019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson if (isa<llvm::VectorType>(Src->getType()) || 6073b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner isa<llvm::VectorType>(DstTy)) 6087019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson return Builder.CreateBitCast(Src, DstTy, "conv"); 609db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 6103707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Finally, we have the arithmetic types: real int/float. 6113707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(Src->getType())) { 612575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool InputSigned = SrcType->isSignedIntegerOrEnumerationType(); 613b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (isa<llvm::IntegerType>(DstTy)) 614b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 615b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else if (InputSigned) 616b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateSIToFP(Src, DstTy, "conv"); 617b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 618b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateUIToFP(Src, DstTy, "conv"); 6193707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 620db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 621f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(Src->getType()->isFloatingPointTy() && "Unknown real conversion"); 6223707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(DstTy)) { 623575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (DstType->isSignedIntegerOrEnumerationType()) 624b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToSI(Src, DstTy, "conv"); 625b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 626b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToUI(Src, DstTy, "conv"); 6273707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 6283707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 629f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(DstTy->isFloatingPointTy() && "Unknown real conversion"); 630b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstTy->getTypeID() < Src->getType()->getTypeID()) 631b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPTrunc(Src, DstTy, "conv"); 632b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 633b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPExt(Src, DstTy, "conv"); 6343707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 6353707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 636db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 637db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 638db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 6394f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter:: 6404f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerEmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 6414f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy) { 642ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Get the source element type. 643183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall SrcTy = SrcTy->getAs<ComplexType>()->getElementType(); 644db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 645ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 646ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstTy->isBooleanType()) { 647ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Complex != 0 -> (Real != 0) | (Imag != 0) 648ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 649ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 650ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return Builder.CreateOr(Src.first, Src.second, "tobool"); 651ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner } 652db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 6534f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 6544f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // the imaginary part of the complex value is discarded and the value of the 6554f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // real part is converted according to the conversion rules for the 656db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // corresponding real type. 6574f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return EmitScalarConversion(Src.first, SrcTy, DstTy); 6584f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 6594f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 660a40a9f31218c743e366322e34b59f0d4d4414198Anders CarlssonValue *ScalarExprEmitter::EmitNullValue(QualType Ty) { 6610bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) 6620bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 6630bab0cdab751248ca389a5592bcb70eac5d39260John McCall 6640bab0cdab751248ca389a5592bcb70eac5d39260John McCall return llvm::Constant::getNullValue(ConvertType(Ty)); 665a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson} 6664f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 6677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Visitor Methods 6697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitExpr(Expr *E) { 672488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGF.ErrorUnsupported(E, "scalar expression"); 6737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getType()->isVoidType()) 6747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 67503e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 6767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 6777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 678d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanValue *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 67937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Vector Mask Case 68037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 2 || 6813f4cb120fe574f7b80864f52a1999502a4f3a83dRafael Espindola (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { 68277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *LHS = CGF.EmitScalarExpr(E->getExpr(0)); 68377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *RHS = CGF.EmitScalarExpr(E->getExpr(1)); 68477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Mask; 68537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 68637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType()); 68737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman unsigned LHSElts = LTy->getNumElements(); 68837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 68937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 3) { 69037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = CGF.EmitScalarExpr(E->getExpr(2)); 69137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 69237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Shuffle LHS & RHS into one input vector. 69337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> concat; 69437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0; i != LHSElts; ++i) { 69548431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner concat.push_back(Builder.getInt32(2*i)); 69648431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner concat.push_back(Builder.getInt32(2*i+1)); 69737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 69837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 699fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner Value* CV = llvm::ConstantVector::get(concat); 70037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); 70137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHSElts *= 2; 70237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } else { 70337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = RHS; 70437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 70537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 70637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType()); 70737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant* EltMask; 70837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 70937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Treat vec3 like vec4. 71037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) 71137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 71237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+2))-1); 71337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else if ((LHSElts == 3) && (E->getNumSubExprs() == 2)) 71437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 71537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+1))-1); 71637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else 71737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 71837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts))-1); 71937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 72037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Mask off the high bits of each shuffle index. 72137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant *, 32> MaskV; 72237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) 72337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MaskV.push_back(EltMask); 72437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 725fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner Value* MaskBits = llvm::ConstantVector::get(MaskV); 72637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); 72737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 72837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = undef 72937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // mask = mask & maskbits 73037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // for each elt 73137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // n = extract mask i 73237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // x = extract val n 73337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = insert newv, x, i 73437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(), 73537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MTy->getNumElements()); 73637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* NewV = llvm::UndefValue::get(RTy); 73737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) { 73848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Value *Indx = Builder.getInt32(i); 73937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateExtractElement(Mask, Indx, "shuf_idx"); 74077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext"); 74137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 74237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 74337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { 74437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *cmpIndx, *newIndx; 74548431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner cmpIndx = Builder.CreateICmpUGT(Indx, Builder.getInt32(3), 74637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "cmp_shuf_idx"); 74748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner newIndx = Builder.CreateSub(Indx, Builder.getInt32(1), "shuf_idx_adj"); 74837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx"); 74937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 75037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt"); 75137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman NewV = Builder.CreateInsertElement(NewV, VExt, Indx, "shuf_ins"); 75237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 75337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman return NewV; 754d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 75537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 756d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 757d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 75837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 75937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 7600eb47fc01849a94bac7fda236134f9301eff688bEli Friedman const llvm::VectorType *VTy = cast<llvm::VectorType>(V1->getType()); 76137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> indices; 76237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 7630eb47fc01849a94bac7fda236134f9301eff688bEli Friedman unsigned Idx = E->getShuffleMaskIdx(CGF.getContext(), i-2); 7640eb47fc01849a94bac7fda236134f9301eff688bEli Friedman if (VTy->getNumElements() == 3 && Idx > 3) 7650eb47fc01849a94bac7fda236134f9301eff688bEli Friedman Idx -= 1; 7660eb47fc01849a94bac7fda236134f9301eff688bEli Friedman indices.push_back(Builder.getInt32(Idx)); 76737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 76837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 769fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner Value *SV = llvm::ConstantVector::get(indices); 770d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 771d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 77228665272c36cccb1014a6ea1217354b0519e2b59Eli FriedmanValue *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) { 77328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 77428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 77528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->isArrow()) 77628665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman CGF.EmitScalarExpr(E->getBase()); 77728665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman else 77828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman EmitLValue(E->getBase()); 77948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt(Result.Val.getInt()); 78028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 78178ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel 78278ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // Emit debug info for aggregate now, if it was delayed to reduce 78378ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // debug info size. 78478ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel CGDebugInfo *DI = CGF.getDebugInfo(); 78578ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (DI && CGF.CGM.getCodeGenOpts().LimitDebugInfo) { 78678ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel QualType PQTy = E->getBase()->IgnoreParenImpCasts()->getType(); 78778ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (const PointerType * PTy = dyn_cast<PointerType>(PQTy)) 78849c8465f14fc3b2e1a32c7016ad3fb4e2cf8d466Devang Patel if (FieldDecl *M = dyn_cast<FieldDecl>(E->getMemberDecl())) 78978ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel DI->getOrCreateRecordType(PTy->getPointeeType(), 79078ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel M->getParent()->getLocation()); 7917fa8ab2e77f5703d0adf14e4d98f1edc1e66505dDevang Patel } 79228665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return EmitLoadOfLValue(E); 79328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman} 794d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 7957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 7967f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 7977f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 7987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Emit subscript expressions in rvalue context's. For most cases, this just 7997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // loads the lvalue formed by the subscript expr. However, we have to be 8007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // careful, because the base of a vector subscript is occasionally an rvalue, 8017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // so we can't get it as an lvalue. 8027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (!E->getBase()->getType()->isVectorType()) 8037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 804db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 8057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the vector case. The base must be a vector, the index must be an 8067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // integer value. 8077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Base = Visit(E->getBase()); 8087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Idx = Visit(E->getIdx()); 809575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool IdxSigned = E->getIdx()->getType()->isSignedIntegerOrEnumerationType(); 81077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast"); 8117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateExtractElement(Base, Idx, "vecext"); 8127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 8137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 8140533b3020ca39898751d4200feed776861dcd1ceNate Begemanstatic llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, 8150533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned Off, const llvm::Type *I32Ty) { 8160533b3020ca39898751d4200feed776861dcd1ceNate Begeman int MV = SVI->getMaskValue(Idx); 8170533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (MV == -1) 8180533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::UndefValue::get(I32Ty); 8190533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::ConstantInt::get(I32Ty, Off+MV); 8200533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 8210533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8220533b3020ca39898751d4200feed776861dcd1ceNate BegemanValue *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { 8230533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool Ignore = TestAndClearIgnoreResultAssign(); 8240533b3020ca39898751d4200feed776861dcd1ceNate Begeman (void)Ignore; 8250533b3020ca39898751d4200feed776861dcd1ceNate Begeman assert (Ignore == false && "init list ignored"); 8260533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned NumInitElements = E->getNumInits(); 8270533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8280533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (E->hadArrayRangeDesignator()) 8290533b3020ca39898751d4200feed776861dcd1ceNate Begeman CGF.ErrorUnsupported(E, "GNU array range designator extension"); 8300533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8310533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VType = 8320533b3020ca39898751d4200feed776861dcd1ceNate Begeman dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 8330533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8340533b3020ca39898751d4200feed776861dcd1ceNate Begeman // We have a scalar in braces. Just use the first element. 8350533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VType) 8360533b3020ca39898751d4200feed776861dcd1ceNate Begeman return Visit(E->getInit(0)); 8370533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8380533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned ResElts = VType->getNumElements(); 8390533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8400533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Loop over initializers collecting the Value for each, and remembering 8410533b3020ca39898751d4200feed776861dcd1ceNate Begeman // whether the source was swizzle (ExtVectorElementExpr). This will allow 8420533b3020ca39898751d4200feed776861dcd1ceNate Begeman // us to fold the shuffle for the swizzle into the shuffle for the vector 8430533b3020ca39898751d4200feed776861dcd1ceNate Begeman // initializer, since LLVM optimizers generally do not want to touch 8440533b3020ca39898751d4200feed776861dcd1ceNate Begeman // shuffles. 8450533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned CurIdx = 0; 8460533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool VIsUndefShuffle = false; 8470533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *V = llvm::UndefValue::get(VType); 8480533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned i = 0; i != NumInitElements; ++i) { 8490533b3020ca39898751d4200feed776861dcd1ceNate Begeman Expr *IE = E->getInit(i); 8500533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Init = Visit(IE); 8510533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 8520533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8530533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType()); 8540533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8550533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Handle scalar elements. If the scalar initializer is actually one 8560533b3020ca39898751d4200feed776861dcd1ceNate Begeman // element of a different vector of the same width, use shuffle instead of 8570533b3020ca39898751d4200feed776861dcd1ceNate Begeman // extract+insert. 8580533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VVT) { 8590533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 8600533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init); 8610533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8620533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (EI->getVectorOperandType()->getNumElements() == ResElts) { 8630533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand()); 8640533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *LHS = 0, *RHS = 0; 8650533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) { 8660533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undef -> shuffle (src, undef) 8670533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(C); 8680533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 1; j != ResElts; ++j) 86977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8700533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8710533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = EI->getVectorOperand(); 8720533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = V; 8730533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = true; 8740533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else if (VIsUndefShuffle) { 8750533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undefshuffle && size match -> shuffle (v, src) 8760533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V); 8770533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 87877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty)); 87948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(ResElts + C->getZExtValue())); 8800533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + 1; j != ResElts; ++j) 88177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8820533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8830533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 8840533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = EI->getVectorOperand(); 8850533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8860533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8870533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!Args.empty()) { 888fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 8890533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(LHS, RHS, Mask); 8900533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8910533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8920533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8930533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8940533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 89548431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx), 89648431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner "vecinit"); 8970533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8980533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8990533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 9000533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9010533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9020533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned InitElts = VVT->getNumElements(); 9030533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9040533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's 9050533b3020ca39898751d4200feed776861dcd1ceNate Begeman // input is the same width as the vector being constructed, generate an 9060533b3020ca39898751d4200feed776861dcd1ceNate Begeman // optimized shuffle of the swizzle input into the result. 907a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman unsigned Offset = (CurIdx == 0) ? 0 : ResElts; 9080533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 9090533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init); 9100533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *SVOp = SVI->getOperand(0); 9110533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType()); 9120533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9130533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (OpTy->getNumElements() == ResElts) { 9140533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) { 9150533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the current vector initializer is a shuffle with undef, merge 9160533b3020ca39898751d4200feed776861dcd1ceNate Begeman // this shuffle directly into it. 9170533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) { 9180533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0, 91977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner CGF.Int32Ty)); 9200533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else { 92148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j)); 9220533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9230533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9240533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0, je = InitElts; j != je; ++j) 92577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty)); 9260533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 92777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9280533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9290533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) 9300533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 9310533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9320533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = SVOp; 9330533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9340533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9350533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9360533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Extend init to result vector length, and then shuffle its contribution 9370533b3020ca39898751d4200feed776861dcd1ceNate Begeman // to the vector initializer into V. 9380533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (Args.empty()) { 9390533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 94048431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j)); 9410533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = InitElts; j != ResElts; ++j) 94277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 943fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 9440533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), 945a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman Mask, "vext"); 9460533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9470533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.clear(); 9480533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 94948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j)); 9500533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 95148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j+Offset)); 9520533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 95377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9540533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9550533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9560533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If V is undef, make sure it ends up on the RHS of the shuffle to aid 9570533b3020ca39898751d4200feed776861dcd1ceNate Begeman // merging subsequent shuffles into this one. 9580533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) 9590533b3020ca39898751d4200feed776861dcd1ceNate Begeman std::swap(V, Init); 960fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 9610533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit"); 9620533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = isa<llvm::UndefValue>(Init); 9630533b3020ca39898751d4200feed776861dcd1ceNate Begeman CurIdx += InitElts; 9640533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9650533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9660533b3020ca39898751d4200feed776861dcd1ceNate Begeman // FIXME: evaluate codegen vs. shuffling against constant null vector. 9670533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers. 9680533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::Type *EltTy = VType->getElementType(); 9690533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9700533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers 9710533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { 97248431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Value *Idx = Builder.getInt32(CurIdx); 9730533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *Init = llvm::Constant::getNullValue(EltTy); 9740533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 9750533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9760533b3020ca39898751d4200feed776861dcd1ceNate Begeman return V; 9770533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 9780533b3020ca39898751d4200feed776861dcd1ceNate Begeman 979a3697c9c155bda93fd2802f37084b620f4738822Anders Carlssonstatic bool ShouldNullCheckClassCastValue(const CastExpr *CE) { 980a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const Expr *E = CE->getSubExpr(); 98123cba801e11b03929c44f8cf54578305963a3476John McCall 9822de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CE->getCastKind() == CK_UncheckedDerivedToBase) 98323cba801e11b03929c44f8cf54578305963a3476John McCall return false; 984a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 985a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (isa<CXXThisExpr>(E)) { 986a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // We always assume that 'this' is never null. 987a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 988a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 989a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 990a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) { 991906082edf2aea1c6de2926f93a8d7121e49d2a54Sebastian Redl // And that glvalue casts are never null. 9925baba9d98364a3525d6afa15a04cdad82fd6dd30John McCall if (ICE->getValueKind() != VK_RValue) 993a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 994a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 995a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 996a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return true; 997a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson} 998a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 999504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 1000504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// have to handle a more broad range of conversions than explicit casts, as they 1001504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// handle things like function to ptr-to-function decay etc. 1002bc8d40d85f3fa1e34569834916f18fecaa635152John McCallValue *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { 1003d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Expr *E = CE->getSubExpr(); 1004592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson QualType DestTy = CE->getType(); 10052de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CastKind Kind = CE->getCastKind(); 1006592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson 1007504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson if (!DestTy->isVoidType()) 1008504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson TestAndClearIgnoreResultAssign(); 1009db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10108c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // Since almost all cast kinds apply to scalars, this switch doesn't have 10118c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // a default case, so the compiler will warn on a missing case. The cases 10128c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // are in the same order as in the CastKind enum. 1013504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson switch (Kind) { 1014daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!"); 1015daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 10162de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_LValueBitCast: 10172de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ObjCObjectLValueCast: { 1018e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor Value *V = EmitLValue(E).getAddress(); 1019e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor V = Builder.CreateBitCast(V, 1020e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor ConvertType(CGF.getContext().getPointerType(DestTy))); 1021545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy)); 1022e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor } 1023e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor 10242de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_AnyPointerToObjCPointerCast: 10252de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_AnyPointerToBlockPointerCast: 10262de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BitCast: { 1027cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 1028cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson return Builder.CreateBitCast(Src, ConvertType(DestTy)); 1029cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson } 10302de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NoOp: 10312de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UserDefinedConversion: 1032ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Visit(const_cast<Expr*>(E)); 1033db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10342de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerived: { 1035a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const CXXRecordDecl *DerivedClassDecl = 1036a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson DestTy->getCXXRecordDeclForPointerType(); 1037a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 1038a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl, 1039f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 1040a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson ShouldNullCheckClassCastValue(CE)); 1041a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 10422de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UncheckedDerivedToBase: 10432de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBase: { 1044191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson const RecordType *DerivedClassTy = 1045191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson E->getType()->getAs<PointerType>()->getPointeeType()->getAs<RecordType>(); 1046191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson CXXRecordDecl *DerivedClassDecl = 1047191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1048191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 104934a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, 1050f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 105134a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson ShouldNullCheckClassCastValue(CE)); 1052191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson } 1053575b374fdbfc2c2224fd3047ac11ffc4b8db9ae5Anders Carlsson case CK_Dynamic: { 10548c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman Value *V = Visit(const_cast<Expr*>(E)); 10558c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE); 10568c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman return CGF.EmitDynamicCast(V, DCE); 10578c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman } 1058d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 10592de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ArrayToPointerDecay: { 1060ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(E->getType()->isArrayType() && 1061ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Array to pointer decay must have array source type!"); 1062ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1063ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *V = EmitLValue(E).getAddress(); // Bitfields can't be arrays. 1064ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1065ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Note that VLA pointers are always decayed, so we don't need to do 1066ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // anything here. 1067ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman if (!E->getType()->isVariableArrayType()) { 1068ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 1069ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 1070ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman ->getElementType()) && 1071ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Expected pointer to array"); 1072ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman V = Builder.CreateStructGEP(V, 0, "arraydecay"); 1073ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1074ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1075ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return V; 1076ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 10772de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FunctionToPointerDecay: 1078ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return EmitLValue(E).getAddress(); 1079ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1080404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall case CK_NullToPointer: 1081404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall if (MustVisitNullValue(E)) 1082404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall (void) Visit(E); 1083404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 1084404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall return llvm::ConstantPointerNull::get( 1085404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall cast<llvm::PointerType>(ConvertType(DestTy))); 1086404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 10872de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NullToMemberPointer: { 1088404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall if (MustVisitNullValue(E)) 1089d608cdb7c044365cf4e8764ade1e11e99c176078John McCall (void) Visit(E); 1090d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 10910bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>(); 10920bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 10930bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 1094191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 10952de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerivedMemberPointer: 10962de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBaseMemberPointer: { 1097d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *Src = Visit(E); 1098d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 1099d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // Note that the AST doesn't distinguish between checked and 1100d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // unchecked member pointer conversions, so we always have to 1101d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // implement checked conversions here. This is inefficient when 1102d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // actual control flow may be required in order to perform the 1103d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // check, which it is for data member pointers (but not member 1104d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // function pointers on Itanium and ARM). 11050bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src); 1106d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 1107f85e193739c953358c865005855253af4f68a497John McCall 1108f85e193739c953358c865005855253af4f68a497John McCall case CK_ObjCProduceObject: 1109f85e193739c953358c865005855253af4f68a497John McCall return CGF.EmitARCRetainScalarExpr(E); 1110f85e193739c953358c865005855253af4f68a497John McCall case CK_ObjCConsumeObject: 1111f85e193739c953358c865005855253af4f68a497John McCall return CGF.EmitObjCConsumeObject(E->getType(), Visit(E)); 11127e5e5f4cc36fe50f46ad76dca7a266434c94f475John McCall case CK_ObjCReclaimReturnedObject: { 11137e5e5f4cc36fe50f46ad76dca7a266434c94f475John McCall llvm::Value *value = Visit(E); 11147e5e5f4cc36fe50f46ad76dca7a266434c94f475John McCall value = CGF.EmitARCRetainAutoreleasedReturnValue(value); 11157e5e5f4cc36fe50f46ad76dca7a266434c94f475John McCall return CGF.EmitObjCConsumeObject(E->getType(), value); 11167e5e5f4cc36fe50f46ad76dca7a266434c94f475John McCall } 1117f85e193739c953358c865005855253af4f68a497John McCall 11182bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingRealToComplex: 11192bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingComplexCast: 11202bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralRealToComplex: 11212bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralComplexCast: 1122f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToFloatingComplex: 1123f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToIntegralComplex: 11242de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ConstructorConversion: 112561ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall case CK_ToUnion: 112661ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall llvm_unreachable("scalar cast to non-scalar value"); 11278c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman break; 1128f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall 1129f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall case CK_GetObjCProperty: { 1130f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)); 1131da29e091650dc011df5209578d7c049549e5e34bDouglas Gregor assert(E->isGLValue() && E->getObjectKind() == OK_ObjCProperty && 1132f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall "CK_GetObjCProperty for non-lvalue or non-ObjCProperty"); 1133545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall RValue RV = CGF.EmitLoadOfLValue(CGF.EmitLValue(E)); 1134f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall return RV.getScalarVal(); 1135f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall } 11361de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall 11370ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall case CK_LValueToRValue: 11380ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)); 1139f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(E->isGLValue() && "lvalue-to-rvalue applied to r-value!"); 11400ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall return Visit(const_cast<Expr*>(E)); 11418c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman 11422de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToPointer: { 11437f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 114489f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 114582debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // First, convert to the correct width so that we control the kind of 114682debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // extension. 114777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 1148575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool InputSigned = E->getType()->isSignedIntegerOrEnumerationType(); 114982debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson llvm::Value* IntResult = 115082debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 115189f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 115282debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy)); 11537f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 11546594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_PointerToIntegral: 11556594942e98e25640f226aba622eb76bcaf0a521cEli Friedman assert(!DestTy->isBooleanType() && "bool should use PointerToBool"); 11566594942e98e25640f226aba622eb76bcaf0a521cEli Friedman return Builder.CreatePtrToInt(Visit(E), ConvertType(DestTy)); 115789f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 11582de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ToVoid: { 11592a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E); 1160ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return 0; 1161ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 11622de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_VectorSplat: { 1163ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman const llvm::Type *DstTy = ConvertType(DestTy); 1164ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *Elt = Visit(const_cast<Expr*>(E)); 1165ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1166ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Insert the element in element zero of an undef vector 1167ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *UnV = llvm::UndefValue::get(DstTy); 116848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *Idx = Builder.getInt32(0); 1169ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 1170ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1171ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Splat the element across to all elements 1172ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::SmallVector<llvm::Constant*, 16> Args; 1173ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 117448431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Constant *Zero = Builder.getInt32(0); 1175ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman for (unsigned i = 0; i < NumElements; i++) 1176daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Args.push_back(Zero); 1177ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1178fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 1179ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 1180ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Yay; 1181ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1182daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 11832de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralCast: 11842de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToFloating: 11852de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingToIntegral: 11862de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingCast: 1187d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return EmitScalarConversion(Visit(E), E->getType(), DestTy); 1188ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1189daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_IntegralToBoolean: 1190daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitIntToBoolConversion(Visit(E)); 1191daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_PointerToBoolean: 1192daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitPointerToBoolConversion(Visit(E)); 1193daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_FloatingToBoolean: 1194daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitFloatToBoolConversion(Visit(E)); 11952de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_MemberPointerToBoolean: { 11960bab0cdab751248ca389a5592bcb70eac5d39260John McCall llvm::Value *MemPtr = Visit(E); 11970bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>(); 11980bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT); 1199e9776247577715ad3a19461769a3488a445a8cbdAnders Carlsson } 1200f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1201f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToReal: 1202f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToReal: 1203b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(E, false, true).first; 1204f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1205f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToBoolean: 1206f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToBoolean: { 1207b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall CodeGenFunction::ComplexPairTy V = CGF.EmitComplexExpr(E); 1208f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1209f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall // TODO: kill this function off, inline appropriate case here 1210f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall return EmitComplexToScalarConversion(V, E->getType(), DestTy); 1211f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall } 1212f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 12130bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 121410b00cfe6422906b223724048b9b2123968d3baaChris Lattner 121561ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall llvm_unreachable("unknown scalar cast"); 121619a1d7c646729eb858b15583e647262a22de3637Chris Lattner return 0; 12177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12193379320c10001d7e1ee5d7e7142c417f797cfe82Chris LattnerValue *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 1220150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::StmtExprEvaluation eval(CGF); 1221150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall return CGF.EmitCompoundStmt(*E->getSubStmt(), !E->getType()->isVoidType()) 1222150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall .getScalarVal(); 12233379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner} 12243379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 1225a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike StumpValue *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 1226a5bcb8fec45d127501cd70fe1654b5a08a8aeb35John McCall LValue LV = CGF.EmitBlockDeclRefLValue(E); 1227545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return CGF.EmitLoadOfLValue(LV).getScalarVal(); 12284e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump} 12293379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 12307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Unary Operators 12327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12348c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *ScalarExprEmitter:: 1235683564a7a93c952f1fbe573b55c542418d29d859Anton YartsevEmitAddConsiderOverflowBehavior(const UnaryOperator *E, 1236683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *InVal, 1237683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *NextVal, bool IsInc) { 1238683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1239683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Undefined: 1240683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return Builder.CreateNSWAdd(InVal, NextVal, IsInc ? "inc" : "dec"); 1241683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev break; 1242683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Defined: 1243683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return Builder.CreateAdd(InVal, NextVal, IsInc ? "inc" : "dec"); 1244683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev break; 1245683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Trapping: 1246683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOpInfo BinOp; 1247683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.LHS = InVal; 1248683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.RHS = NextVal; 1249683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.Ty = E->getType(); 1250683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.Opcode = BO_Add; 1251683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.E = E; 1252683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return EmitOverflowCheckedBinOp(BinOp); 1253683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev break; 1254683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } 1255683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev assert(false && "Unknown SignedOverflowBehaviorTy"); 1256683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return 0; 1257683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev} 1258683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 12595936e33bf74dd6bf126ceee0f6169a2593d03a69John McCallllvm::Value * 12605936e33bf74dd6bf126ceee0f6169a2593d03a69John McCallScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 12615936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall bool isInc, bool isPre) { 12628c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12635936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall QualType type = E->getSubExpr()->getType(); 1264545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall llvm::Value *value = EmitLoadOfLValue(LV); 12655936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *input = value; 12665936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 12675936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall int amount = (isInc ? 1 : -1); 12685936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 12695936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Special case of integer increment that we have to check first: bool++. 12705936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Due to promotion rules, we get: 12715936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // bool++ -> bool = bool + 1 12725936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // -> bool = (int)bool + 1 12735936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // -> bool = ((int)bool + 1 != 0) 12745936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // An interesting aspect of this is that increment is always true. 12755936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Decrement does not have this property. 12765936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (isInc && type->isBooleanType()) { 12775936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.getTrue(); 12785936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 12795936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Most common case by far: integer increment. 12805936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isIntegerType()) { 12815936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 12825936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount); 12835936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 1284fa0b409ef81f1f70edfa72857c4e211ff50998d5Eli Friedman // Note that signed integer inc/dec with width less than int can't 1285fa0b409ef81f1f70edfa72857c4e211ff50998d5Eli Friedman // overflow because of promotion rules; we're just eliding a few steps here. 1286575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (type->isSignedIntegerOrEnumerationType() && 1287fa0b409ef81f1f70edfa72857c4e211ff50998d5Eli Friedman value->getType()->getPrimitiveSizeInBits() >= 1288913dab2525cc705e5238023a446f5371fa411883John McCall CGF.IntTy->getBitWidth()) 12895936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = EmitAddConsiderOverflowBehavior(E, value, amt, isInc); 12905936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall else 12915936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec"); 12928c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12935936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Next most common: pointer increment. 12945936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (const PointerType *ptr = type->getAs<PointerType>()) { 12955936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall QualType type = ptr->getPointeeType(); 12965936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 12975936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // VLA types don't have constant size. 1298913dab2525cc705e5238023a446f5371fa411883John McCall if (const VariableArrayType *vla 1299913dab2525cc705e5238023a446f5371fa411883John McCall = CGF.getContext().getAsVariableArrayType(type)) { 1300913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *numElts = CGF.getVLASize(vla).first; 1301bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize"); 13022cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 1303bc8d40d85f3fa1e34569834916f18fecaa635152John McCall value = Builder.CreateGEP(value, numElts, "vla.inc"); 13042cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 1305bc8d40d85f3fa1e34569834916f18fecaa635152John McCall value = Builder.CreateInBoundsGEP(value, numElts, "vla.inc"); 13065936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13075936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Arithmetic on function pointers (!) is just +-1. 13085936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isFunctionType()) { 130948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *amt = Builder.getInt32(amount); 13105936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13115936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = CGF.EmitCastToVoidPtr(value); 13122cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 13132cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateGEP(value, amt, "incdec.funcptr"); 13142cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 13152cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateInBoundsGEP(value, amt, "incdec.funcptr"); 13165936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateBitCast(value, input->getType()); 13175936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13185936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // For everything else, we can just do a simple increment. 13198c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 132048431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *amt = Builder.getInt32(amount); 13212cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 13222cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateGEP(value, amt, "incdec.ptr"); 13232cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 13242cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateInBoundsGEP(value, amt, "incdec.ptr"); 13258c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 13265936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13275936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Vector increment/decrement. 13285936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isVectorType()) { 13295936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (type->hasIntegerRepresentation()) { 13305936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount); 13315936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 1332d4b9ee3b6ad82843c55909d6499232fce530113eEli Friedman value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec"); 1333683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } else { 13345936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateFAdd( 13355936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value, 13365936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::ConstantFP::get(value->getType(), amount), 1337683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev isInc ? "inc" : "dec"); 1338683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } 1339683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 13405936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Floating point. 13415936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isRealFloatingType()) { 13428c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Add the inc/dec to the real part. 13435936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *amt; 13445936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (value->getType()->isFloatTy()) 13455936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall amt = llvm::ConstantFP::get(VMContext, 13465936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::APFloat(static_cast<float>(amount))); 13475936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall else if (value->getType()->isDoubleTy()) 13485936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall amt = llvm::ConstantFP::get(VMContext, 13495936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::APFloat(static_cast<double>(amount))); 13508c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else { 13515936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::APFloat F(static_cast<float>(amount)); 13528c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool ignored; 13538c11a65c18ae607b7073e1e451264492d2297726Chris Lattner F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 13548c11a65c18ae607b7073e1e451264492d2297726Chris Lattner &ignored); 13555936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall amt = llvm::ConstantFP::get(VMContext, F); 13568c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 13575936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec"); 13585936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13595936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Objective-C pointer types. 13605936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else { 13615936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall const ObjCObjectPointerType *OPT = type->castAs<ObjCObjectPointerType>(); 13625936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = CGF.EmitCastToVoidPtr(value); 13635936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13645936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType()); 13655936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (!isInc) size = -size; 13665936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *sizeValue = 13675936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::ConstantInt::get(CGF.SizeTy, size.getQuantity()); 13685936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13692cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 13702cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateGEP(value, sizeValue, "incdec.objptr"); 13712cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 13722cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateInBoundsGEP(value, sizeValue, "incdec.objptr"); 13735936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateBitCast(value, input->getType()); 13748c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 13758c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13768c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Store the updated result through the lvalue. 13778c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (LV.isBitField()) 1378545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughBitfieldLValue(RValue::get(value), LV, &value); 13798c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else 1380545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughLValue(RValue::get(value), LV); 13818c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13828c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // If this is a postinc, return the value read from memory, otherwise use the 13838c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // updated value. 13845936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall return isPre ? value : input; 13858c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 13868c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13878c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13888c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 13907f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 13919a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Emit unary minus with EmitSub so we handle overflow cases etc. 13929a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOpInfo BinOp; 13934ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.RHS = Visit(E->getSubExpr()); 13944ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner 13954ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner if (BinOp.RHS->getType()->isFPOrFPVectorTy()) 13964ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType()); 13974ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner else 13984ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType()); 13999a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.Ty = E->getType(); 14002de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall BinOp.Opcode = BO_Sub; 14019a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.E = E; 14029a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner return EmitSub(BinOp); 14037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 14067f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 14077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 14087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNot(Op, "neg"); 14097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 14127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Compare operand to zero. 14137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 1414db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 14157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Invert value. 14167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // TODO: Could dynamically modify easy computations here. For example, if 14177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // the operand is an icmp ne, turn into icmp eq. 14187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BoolVal = Builder.CreateNot(BoolVal, "lnot"); 1419db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 14209f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson // ZExt result to the expr type. 14219f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext"); 14227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14240027d2bb24db629a33a71d04a5fb90a14c15a680Eli FriedmanValue *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) { 14250027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Try folding the offsetof to a constant. 14260027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr::EvalResult EvalResult; 14270027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (E->Evaluate(EvalResult, CGF.getContext())) 142848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt(EvalResult.Val.getInt()); 14290027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14300027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Loop over the components of the offsetof to compute the value. 14310027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned n = E->getNumComponents(); 14320027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const llvm::Type* ResultType = ConvertType(E->getType()); 14330027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Result = llvm::Constant::getNullValue(ResultType); 14340027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman QualType CurrentType = E->getTypeSourceInfo()->getType(); 14350027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (unsigned i = 0; i != n; ++i) { 14360027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman OffsetOfExpr::OffsetOfNode ON = E->getComponent(i); 143716fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman llvm::Value *Offset = 0; 14380027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman switch (ON.getKind()) { 14390027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Array: { 14400027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index 14410027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex()); 14420027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr); 1443575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool IdxSigned = IdxExpr->getType()->isSignedIntegerOrEnumerationType(); 14440027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv"); 14450027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14460027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type 14470027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = 14480027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getAsArrayType(CurrentType)->getElementType(); 14490027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14500027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the element size 14510027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType, 14520027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity()); 14530027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14540027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Multiply out to compute the result 14550027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = Builder.CreateMul(Idx, ElemSize); 14560027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14570027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14580027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14590027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Field: { 14600027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldDecl *MemberDecl = ON.getField(); 14610027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 14620027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 14630027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14640027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index of the field in its parent. 14650027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned i = 0; 14660027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // FIXME: It would be nice if we didn't have to loop here! 14670027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (RecordDecl::field_iterator Field = RD->field_begin(), 14680027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldEnd = RD->field_end(); 14690027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Field != FieldEnd; (void)++Field, ++i) { 14700027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (*Field == MemberDecl) 14710027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14720027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14730027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman assert(i < RL.getFieldCount() && "offsetof field in wrong type"); 14740027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14750027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the field 14760027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman int64_t OffsetInt = RL.getFieldOffset(i) / 14770027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 14780027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 14790027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14800027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 14810027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = MemberDecl->getType(); 14820027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14830027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 148416fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 14850027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Identifier: 14866d4e44b462fe9e870a40358522379400ccc6e3c2Eli Friedman llvm_unreachable("dependent __builtin_offsetof"); 148716fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 14880027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Base: { 14890027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (ON.getBase()->isVirtual()) { 14900027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.ErrorUnsupported(E, "virtual base in offsetof"); 14910027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman continue; 14920027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14930027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14940027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 14950027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 14960027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14970027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 14980027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = ON.getBase()->getType(); 14990027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 15000027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the base. 15010027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const RecordType *BaseRT = CurrentType->getAs<RecordType>(); 15020027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl()); 1503a14f5979572aa25c03d24750ee4724d2031d4edeAnders Carlsson int64_t OffsetInt = RL.getBaseClassOffsetInBits(BaseRD) / 15040027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 15050027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 15060027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 15070027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15080027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15090027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Result = Builder.CreateAdd(Result, Offset); 15100027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15110027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman return Result; 15128ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor} 15138ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 1514f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne/// VisitUnaryExprOrTypeTraitExpr - Return the size or alignment of the type of 15150518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// argument of the sizeof expression as an integer. 15160518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlValue * 1517f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter CollingbourneScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr( 1518f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne const UnaryExprOrTypeTraitExpr *E) { 15190518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl QualType TypeToSize = E->getTypeOfArgument(); 1520f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne if (E->getKind() == UETT_SizeOf) { 1521db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (const VariableArrayType *VAT = 1522f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.getContext().getAsVariableArrayType(TypeToSize)) { 1523f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isArgumentType()) { 1524f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // sizeof(type) - make sure to emit the VLA size. 1525bc8d40d85f3fa1e34569834916f18fecaa635152John McCall CGF.EmitVariablyModifiedType(TypeToSize); 15268f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman } else { 15278f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // C99 6.5.3.4p2: If the argument is an expression of type 15288f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // VLA, it is evaluated. 15292a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E->getArgumentExpr()); 1530f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman } 1531db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1532bc8d40d85f3fa1e34569834916f18fecaa635152John McCall QualType eltType; 1533bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *numElts; 1534bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::tie(numElts, eltType) = CGF.getVLASize(VAT); 1535bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1536bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *size = numElts; 1537bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1538bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Scale the number of non-VLA elements by the non-VLA element size. 1539bc8d40d85f3fa1e34569834916f18fecaa635152John McCall CharUnits eltSize = CGF.getContext().getTypeSizeInChars(eltType); 1540bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (!eltSize.isOne()) 1541bc8d40d85f3fa1e34569834916f18fecaa635152John McCall size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), numElts); 1542bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1543bc8d40d85f3fa1e34569834916f18fecaa635152John McCall return size; 1544b50525ba0e996bc072cdb76152fcfe0bc64bb72aAnders Carlsson } 15455d46315ca3cbbfe0d0f5f65520b618fb05dd4446Anders Carlsson } 1546f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman 1547db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If this isn't sizeof(vla), the result must be constant; use the constant 1548db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // folding logic so we don't have to duplicate it here. 1549f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman Expr::EvalResult Result; 1550f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman E->Evaluate(Result, CGF.getContext()); 155148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt(Result.Val.getInt()); 15527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 15537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 155446f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 155546f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 1556b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (Op->getType()->isAnyComplexType()) { 1557b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If it's an l-value, load through the appropriate subobject l-value. 1558b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Note that we have to ask E because Op might be an l-value that 1559b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // this won't work for, e.g. an Obj-C property. 15607eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (E->isGLValue()) 1561545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return CGF.EmitLoadOfLValue(CGF.EmitLValue(E)).getScalarVal(); 1562b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1563b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Otherwise, calculate and project. 1564b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(Op, false, true).first; 1565b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall } 1566b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 156746f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return Visit(Op); 156846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 1569b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 157046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 157146f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 1572b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (Op->getType()->isAnyComplexType()) { 1573b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If it's an l-value, load through the appropriate subobject l-value. 1574b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Note that we have to ask E because Op might be an l-value that 1575b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // this won't work for, e.g. an Obj-C property. 15767eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (Op->isGLValue()) 1577545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return CGF.EmitLoadOfLValue(CGF.EmitLValue(E)).getScalarVal(); 1578b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1579b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Otherwise, calculate and project. 1580b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(Op, true, false).second; 1581b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall } 1582db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 15837f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __imag on a scalar returns zero. Emit the subexpr to ensure side 15847f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // effects are evaluated, but not the actual value. 1585b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall CGF.EmitScalarExpr(Op, true); 1586c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson return llvm::Constant::getNullValue(ConvertType(E->getType())); 158746f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 158846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 15897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 15907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Binary Operators 15917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 15927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerBinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 15947f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 15957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BinOpInfo Result; 15967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.LHS = Visit(E->getLHS()); 15977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.RHS = Visit(E->getRHS()); 15981f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Result.Ty = E->getType(); 15999a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner Result.Opcode = E->getOpcode(); 16007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.E = E; 16017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Result; 16027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 16037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16046a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue ScalarExprEmitter::EmitCompoundAssignLValue( 16056a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E, 16066a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), 1607d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result) { 160854d76db0aa7107597cac0b80d8e138a37e6d1de9Benjamin Kramer QualType LHSTy = E->getLHS()->getType(); 16091f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo OpInfo; 16106a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1611ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman if (E->getComputationResultType()->isAnyComplexType()) { 1612db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // This needs to go through the complex expression emitter, but it's a tad 1613db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // complicated to do that... I'm leaving it out for now. (Note that we do 1614db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // actually need the imaginary part of the RHS for multiplication and 1615db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // division.) 1616ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman CGF.ErrorUnsupported(E, "complex compound assignment"); 1617d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = llvm::UndefValue::get(CGF.ConvertType(E->getType())); 16186a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LValue(); 16191f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 16206a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1621cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // Emit the RHS first. __block variables need to have the rhs evaluated 1622cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // first, plus this should improve codegen a little. 1623cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.RHS = Visit(E->getRHS()); 1624cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.Ty = E->getComputationResultType(); 16259a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OpInfo.Opcode = E->getOpcode(); 1626cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.E = E; 1627ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // Load/convert the LHS. 1628b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHSLV = EmitCheckedLValue(E->getLHS()); 1629545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall OpInfo.LHS = EmitLoadOfLValue(LHSLV); 1630ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 1631ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman E->getComputationLHSType()); 16326a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 16331f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Expand the binary operator. 1634d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = (this->*Func)(OpInfo); 16356a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 16368c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Convert the result back to the LHS type. 1637ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 16386a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1639db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Store the result value into the LHS lvalue. Bit-fields are handled 1640db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // specially because the result is altered by the store, i.e., [C99 6.5.16p1] 1641db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // 'An assignment expression has the value of the left operand after the 1642db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // assignment...'. 1643d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHSLV.isBitField()) 1644545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, &Result); 1645d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 1646545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV); 1647d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 16486a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LHSLV; 16496a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 16506a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 16516a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorValue *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 16526a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 16536a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor bool Ignore = TestAndClearIgnoreResultAssign(); 1654d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *RHS; 1655d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar LValue LHS = EmitCompoundAssignLValue(E, Func, RHS); 1656d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1657d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 16587f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 16597f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 1660d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1661b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 1662b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!CGF.getContext().getLangOptions().CPlusPlus) 1663b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return RHS; 1664b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1665d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 1666119a1c6c4029d30cae7b31a2826aa0ff70d01668John McCall if (LHS.isPropertyRef()) 1667d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1668d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1669d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 1670d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 1671d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1672d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1673d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 1674545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return EmitLoadOfLValue(LHS); 16751f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner} 16761f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 16778023030f76d334355b73d9c675d3870858aaf4fdChris Lattnervoid ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck( 16788023030f76d334355b73d9c675d3870858aaf4fdChris Lattner const BinOpInfo &Ops, 16798023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero, bool isDiv) { 168014ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::Function::iterator insertPt = Builder.GetInsertBlock(); 16818023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *contBB = 168214ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling CGF.createBasicBlock(isDiv ? "div.cont" : "rem.cont", CGF.CurFn, 168314ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::next(insertPt)); 168414ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 16858023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16868023030f76d334355b73d9c675d3870858aaf4fdChris Lattner const llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType()); 16878023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16888023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->hasSignedIntegerRepresentation()) { 16898023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *IntMin = 169048431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth())); 16918023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL); 16928023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16938023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond1 = Builder.CreateICmpEQ(Ops.RHS, Zero); 16948023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *LHSCmp = Builder.CreateICmpEQ(Ops.LHS, IntMin); 16958023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *RHSCmp = Builder.CreateICmpEQ(Ops.RHS, NegOne); 16968023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond2 = Builder.CreateAnd(LHSCmp, RHSCmp, "and"); 16978023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCondBr(Builder.CreateOr(Cond1, Cond2, "or"), 16988023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 16998023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } else { 17008023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateICmpEQ(Ops.RHS, Zero), 17018023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 17028023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 17038023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 17048023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(contBB); 17058023030f76d334355b73d9c675d3870858aaf4fdChris Lattner} 17061f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 17077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 17088023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 17098023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 17108023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 17118023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 17128023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true); 17138023030f76d334355b73d9c675d3870858aaf4fdChris Lattner else if (Ops.Ty->isRealFloatingType()) { 171414ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::Function::iterator insertPt = Builder.GetInsertBlock(); 171514ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::BasicBlock *DivCont = CGF.createBasicBlock("div.cont", CGF.CurFn, 171614ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::next(insertPt)); 17178023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", 17188023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.CurFn); 17198023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero), 17208023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, DivCont); 17218023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 17228023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(DivCont); 17238023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 17248023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 1725f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 17267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 1727f60946222721d9ba3c059563935c17b84703187aDouglas Gregor else if (Ops.Ty->hasUnsignedIntegerRepresentation()) 17287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 17297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 17307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 17317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 17347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Rem in C can't be a floating point type: C99 6.5.5p2. 17358023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 17368023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 17378023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 17388023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 17398023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false); 17408023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 17418023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 174252d6874271829c4f5bb70121fb678c27780ce65aEli Friedman if (Ops.Ty->hasUnsignedIntegerRepresentation()) 17437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 17447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 17457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 17467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17482add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike StumpValue *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 17492add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned IID; 17502add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned OpID = 0; 17515d8b2cf9fd704f6ca5e33525803a65421c0b440eMike Stump 17529a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner switch (Ops.Opcode) { 17532de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 17542de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_AddAssign: 1755035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 1; 1756035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::sadd_with_overflow; 1757035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 17582de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 17592de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_SubAssign: 1760035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 2; 1761035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::ssub_with_overflow; 1762035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 17632de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 17642de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_MulAssign: 1765035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 3; 1766035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::smul_with_overflow; 1767035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1768035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump default: 1769035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump assert(false && "Unsupported operation for overflow detection"); 1770ab4eff620a9ce0ea62cdf29529a66c2c98d116f5Daniel Dunbar IID = 0; 1771035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump } 1772035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID <<= 1; 1773035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID |= 1; 1774035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump 17759cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattner llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 17762add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17772add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1); 17782add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17792add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 17802add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 17812add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 17822add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17832add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Branch in case of overflow. 17847f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::BasicBlock *initialBB = Builder.GetInsertBlock(); 178514ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::Function::iterator insertPt = initialBB; 178614ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn, 178714ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::next(insertPt)); 178893a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 17892add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17902add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateCondBr(overflow, overflowBB, continueBB); 17912add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 179293a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner // Handle overflow with llvm.trap. 17937f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall const std::string *handlerName = 17947f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall &CGF.getContext().getLangOptions().OverflowHandler; 17957f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall if (handlerName->empty()) { 17967f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall EmitOverflowBB(overflowBB); 17977f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(continueBB); 17987f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return result; 17997f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall } 18007f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18017f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // If an overflow handler is set, then we want to call it and then use its 18027f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // result, if it returns. 18037f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(overflowBB); 18047f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18057f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Get the overflow handler. 18069cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattner llvm::Type *Int8Ty = llvm::Type::getInt8Ty(VMContext); 18079cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattner llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty }; 18087f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType *handlerTy = 18097f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType::get(CGF.Int64Ty, argTypes, true); 18107f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName); 18117f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18127f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Sign extend the args to 64-bit, so that we can use the same handler for 18137f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // all types of overflow. 18147f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty); 18157f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty); 18167f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18177f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Call the handler with the two arguments, the operation, and the size of 18187f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // the result. 18197f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handlerResult = Builder.CreateCall4(handler, lhs, rhs, 18207f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(OpID), 18217f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())); 18227f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18237f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Truncate the result back to the desired size. 18247f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall handlerResult = Builder.CreateTrunc(handlerResult, opTy); 18257f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.CreateBr(continueBB); 18267f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18272add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(continueBB); 1828bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *phi = Builder.CreatePHI(opTy, 2); 18297f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(result, initialBB); 18307f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(handlerResult, overflowBB); 18317f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18327f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return phi; 18332add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump} 18347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1835913dab2525cc705e5238023a446f5371fa411883John McCall/// Emit pointer + index arithmetic. 1836913dab2525cc705e5238023a446f5371fa411883John McCallstatic Value *emitPointerArithmetic(CodeGenFunction &CGF, 1837913dab2525cc705e5238023a446f5371fa411883John McCall const BinOpInfo &op, 1838913dab2525cc705e5238023a446f5371fa411883John McCall bool isSubtraction) { 1839913dab2525cc705e5238023a446f5371fa411883John McCall // Must have binary (not unary) expr here. Unary pointer 1840913dab2525cc705e5238023a446f5371fa411883John McCall // increment/decrement doesn't use this path. 1841913dab2525cc705e5238023a446f5371fa411883John McCall const BinaryOperator *expr = cast<BinaryOperator>(op.E); 18429a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 1843913dab2525cc705e5238023a446f5371fa411883John McCall Value *pointer = op.LHS; 1844913dab2525cc705e5238023a446f5371fa411883John McCall Expr *pointerOperand = expr->getLHS(); 1845913dab2525cc705e5238023a446f5371fa411883John McCall Value *index = op.RHS; 1846913dab2525cc705e5238023a446f5371fa411883John McCall Expr *indexOperand = expr->getRHS(); 1847913dab2525cc705e5238023a446f5371fa411883John McCall 1848913dab2525cc705e5238023a446f5371fa411883John McCall // In a subtraction, the LHS is always the pointer. 1849913dab2525cc705e5238023a446f5371fa411883John McCall if (!isSubtraction && !pointer->getType()->isPointerTy()) { 1850913dab2525cc705e5238023a446f5371fa411883John McCall std::swap(pointer, index); 1851913dab2525cc705e5238023a446f5371fa411883John McCall std::swap(pointerOperand, indexOperand); 1852913dab2525cc705e5238023a446f5371fa411883John McCall } 1853913dab2525cc705e5238023a446f5371fa411883John McCall 1854913dab2525cc705e5238023a446f5371fa411883John McCall unsigned width = cast<llvm::IntegerType>(index->getType())->getBitWidth(); 1855913dab2525cc705e5238023a446f5371fa411883John McCall if (width != CGF.PointerWidthInBits) { 1856913dab2525cc705e5238023a446f5371fa411883John McCall // Zero-extend or sign-extend the pointer value according to 1857913dab2525cc705e5238023a446f5371fa411883John McCall // whether the index is signed or not. 1858913dab2525cc705e5238023a446f5371fa411883John McCall bool isSigned = indexOperand->getType()->isSignedIntegerOrEnumerationType(); 1859913dab2525cc705e5238023a446f5371fa411883John McCall index = CGF.Builder.CreateIntCast(index, CGF.PtrDiffTy, isSigned, 1860913dab2525cc705e5238023a446f5371fa411883John McCall "idx.ext"); 1861913dab2525cc705e5238023a446f5371fa411883John McCall } 1862913dab2525cc705e5238023a446f5371fa411883John McCall 1863913dab2525cc705e5238023a446f5371fa411883John McCall // If this is subtraction, negate the index. 1864913dab2525cc705e5238023a446f5371fa411883John McCall if (isSubtraction) 1865913dab2525cc705e5238023a446f5371fa411883John McCall index = CGF.Builder.CreateNeg(index, "idx.neg"); 1866913dab2525cc705e5238023a446f5371fa411883John McCall 1867913dab2525cc705e5238023a446f5371fa411883John McCall const PointerType *pointerType 1868913dab2525cc705e5238023a446f5371fa411883John McCall = pointerOperand->getType()->getAs<PointerType>(); 1869913dab2525cc705e5238023a446f5371fa411883John McCall if (!pointerType) { 1870913dab2525cc705e5238023a446f5371fa411883John McCall QualType objectType = pointerOperand->getType() 1871913dab2525cc705e5238023a446f5371fa411883John McCall ->castAs<ObjCObjectPointerType>() 1872913dab2525cc705e5238023a446f5371fa411883John McCall ->getPointeeType(); 1873913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *objectSize 1874913dab2525cc705e5238023a446f5371fa411883John McCall = CGF.CGM.getSize(CGF.getContext().getTypeSizeInChars(objectType)); 1875913dab2525cc705e5238023a446f5371fa411883John McCall 1876913dab2525cc705e5238023a446f5371fa411883John McCall index = CGF.Builder.CreateMul(index, objectSize); 1877913dab2525cc705e5238023a446f5371fa411883John McCall 1878913dab2525cc705e5238023a446f5371fa411883John McCall Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy); 1879913dab2525cc705e5238023a446f5371fa411883John McCall result = CGF.Builder.CreateGEP(result, index, "add.ptr"); 1880913dab2525cc705e5238023a446f5371fa411883John McCall return CGF.Builder.CreateBitCast(result, pointer->getType()); 1881913dab2525cc705e5238023a446f5371fa411883John McCall } 1882913dab2525cc705e5238023a446f5371fa411883John McCall 1883913dab2525cc705e5238023a446f5371fa411883John McCall QualType elementType = pointerType->getPointeeType(); 1884913dab2525cc705e5238023a446f5371fa411883John McCall if (const VariableArrayType *vla 1885913dab2525cc705e5238023a446f5371fa411883John McCall = CGF.getContext().getAsVariableArrayType(elementType)) { 1886913dab2525cc705e5238023a446f5371fa411883John McCall // The element count here is the total number of non-VLA elements. 1887913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *numElements = CGF.getVLASize(vla).first; 1888913dab2525cc705e5238023a446f5371fa411883John McCall 1889913dab2525cc705e5238023a446f5371fa411883John McCall // Effectively, the multiply by the VLA size is part of the GEP. 1890913dab2525cc705e5238023a446f5371fa411883John McCall // GEP indexes are signed, and scaling an index isn't permitted to 1891913dab2525cc705e5238023a446f5371fa411883John McCall // signed-overflow, so we use the same semantics for our explicit 1892913dab2525cc705e5238023a446f5371fa411883John McCall // multiply. We suppress this if overflow is not undefined behavior. 1893913dab2525cc705e5238023a446f5371fa411883John McCall if (CGF.getLangOptions().isSignedOverflowDefined()) { 1894913dab2525cc705e5238023a446f5371fa411883John McCall index = CGF.Builder.CreateMul(index, numElements, "vla.index"); 1895913dab2525cc705e5238023a446f5371fa411883John McCall pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr"); 1896913dab2525cc705e5238023a446f5371fa411883John McCall } else { 1897913dab2525cc705e5238023a446f5371fa411883John McCall index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index"); 1898913dab2525cc705e5238023a446f5371fa411883John McCall pointer = CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr"); 1899913dab2525cc705e5238023a446f5371fa411883John McCall } 1900913dab2525cc705e5238023a446f5371fa411883John McCall return pointer; 1901db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 19022a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1903db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Explicitly handle GNU void* and function pointer arithmetic extensions. The 1904db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // GNU void* casts amount to no-ops since our void* type is i8*, but this is 1905db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // future proof. 1906913dab2525cc705e5238023a446f5371fa411883John McCall if (elementType->isVoidType() || elementType->isFunctionType()) { 1907913dab2525cc705e5238023a446f5371fa411883John McCall Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy); 1908913dab2525cc705e5238023a446f5371fa411883John McCall result = CGF.Builder.CreateGEP(result, index, "add.ptr"); 1909913dab2525cc705e5238023a446f5371fa411883John McCall return CGF.Builder.CreateBitCast(result, pointer->getType()); 1910db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1911db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1912913dab2525cc705e5238023a446f5371fa411883John McCall if (CGF.getLangOptions().isSignedOverflowDefined()) 1913913dab2525cc705e5238023a446f5371fa411883John McCall return CGF.Builder.CreateGEP(pointer, index, "add.ptr"); 1914913dab2525cc705e5238023a446f5371fa411883John McCall 1915913dab2525cc705e5238023a446f5371fa411883John McCall return CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr"); 19167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1918913dab2525cc705e5238023a446f5371fa411883John McCallValue *ScalarExprEmitter::EmitAdd(const BinOpInfo &op) { 1919913dab2525cc705e5238023a446f5371fa411883John McCall if (op.LHS->getType()->isPointerTy() || 1920913dab2525cc705e5238023a446f5371fa411883John McCall op.RHS->getType()->isPointerTy()) 1921913dab2525cc705e5238023a446f5371fa411883John McCall return emitPointerArithmetic(CGF, op, /*subtraction*/ false); 1922913dab2525cc705e5238023a446f5371fa411883John McCall 1923913dab2525cc705e5238023a446f5371fa411883John McCall if (op.Ty->isSignedIntegerOrEnumerationType()) { 1924913dab2525cc705e5238023a446f5371fa411883John McCall switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1925913dab2525cc705e5238023a446f5371fa411883John McCall case LangOptions::SOB_Undefined: 1926913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateNSWAdd(op.LHS, op.RHS, "add"); 1927913dab2525cc705e5238023a446f5371fa411883John McCall case LangOptions::SOB_Defined: 1928913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateAdd(op.LHS, op.RHS, "add"); 1929913dab2525cc705e5238023a446f5371fa411883John McCall case LangOptions::SOB_Trapping: 1930913dab2525cc705e5238023a446f5371fa411883John McCall return EmitOverflowCheckedBinOp(op); 1931913dab2525cc705e5238023a446f5371fa411883John McCall } 1932913dab2525cc705e5238023a446f5371fa411883John McCall } 1933913dab2525cc705e5238023a446f5371fa411883John McCall 1934913dab2525cc705e5238023a446f5371fa411883John McCall if (op.LHS->getType()->isFPOrFPVectorTy()) 1935913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateFAdd(op.LHS, op.RHS, "add"); 1936913dab2525cc705e5238023a446f5371fa411883John McCall 1937913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateAdd(op.LHS, op.RHS, "add"); 1938913dab2525cc705e5238023a446f5371fa411883John McCall} 1939913dab2525cc705e5238023a446f5371fa411883John McCall 1940913dab2525cc705e5238023a446f5371fa411883John McCallValue *ScalarExprEmitter::EmitSub(const BinOpInfo &op) { 1941913dab2525cc705e5238023a446f5371fa411883John McCall // The LHS is always a pointer if either side is. 1942913dab2525cc705e5238023a446f5371fa411883John McCall if (!op.LHS->getType()->isPointerTy()) { 1943913dab2525cc705e5238023a446f5371fa411883John McCall if (op.Ty->isSignedIntegerOrEnumerationType()) { 1944a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1945a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1946913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateNSWSub(op.LHS, op.RHS, "sub"); 1947a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1948913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateSub(op.LHS, op.RHS, "sub"); 1949a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1950913dab2525cc705e5238023a446f5371fa411883John McCall return EmitOverflowCheckedBinOp(op); 1951a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1952a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1953a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1954913dab2525cc705e5238023a446f5371fa411883John McCall if (op.LHS->getType()->isFPOrFPVectorTy()) 1955913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateFSub(op.LHS, op.RHS, "sub"); 19562eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner 1957913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateSub(op.LHS, op.RHS, "sub"); 19582add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 19591f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 1960913dab2525cc705e5238023a446f5371fa411883John McCall // If the RHS is not a pointer, then we have normal pointer 1961913dab2525cc705e5238023a446f5371fa411883John McCall // arithmetic. 1962913dab2525cc705e5238023a446f5371fa411883John McCall if (!op.RHS->getType()->isPointerTy()) 1963913dab2525cc705e5238023a446f5371fa411883John McCall return emitPointerArithmetic(CGF, op, /*subtraction*/ true); 19642a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1965913dab2525cc705e5238023a446f5371fa411883John McCall // Otherwise, this is a pointer subtraction. 1966db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1967913dab2525cc705e5238023a446f5371fa411883John McCall // Do the raw subtraction part. 1968913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *LHS 1969913dab2525cc705e5238023a446f5371fa411883John McCall = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast"); 1970913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *RHS 1971913dab2525cc705e5238023a446f5371fa411883John McCall = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast"); 1972913dab2525cc705e5238023a446f5371fa411883John McCall Value *diffInChars = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 1973db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1974913dab2525cc705e5238023a446f5371fa411883John McCall // Okay, figure out the element size. 1975913dab2525cc705e5238023a446f5371fa411883John McCall const BinaryOperator *expr = cast<BinaryOperator>(op.E); 1976913dab2525cc705e5238023a446f5371fa411883John McCall QualType elementType = expr->getLHS()->getType()->getPointeeType(); 1977df1109434abd465a4db2e6f69ec2688866660367Dan Gohman 1978913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *divisor = 0; 1979913dab2525cc705e5238023a446f5371fa411883John McCall 1980913dab2525cc705e5238023a446f5371fa411883John McCall // For a variable-length array, this is going to be non-constant. 1981913dab2525cc705e5238023a446f5371fa411883John McCall if (const VariableArrayType *vla 1982913dab2525cc705e5238023a446f5371fa411883John McCall = CGF.getContext().getAsVariableArrayType(elementType)) { 1983913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *numElements; 1984913dab2525cc705e5238023a446f5371fa411883John McCall llvm::tie(numElements, elementType) = CGF.getVLASize(vla); 19852cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner 1986913dab2525cc705e5238023a446f5371fa411883John McCall divisor = numElements; 19872cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner 1988913dab2525cc705e5238023a446f5371fa411883John McCall // Scale the number of non-VLA elements by the non-VLA element size. 1989913dab2525cc705e5238023a446f5371fa411883John McCall CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType); 1990913dab2525cc705e5238023a446f5371fa411883John McCall if (!eltSize.isOne()) 1991913dab2525cc705e5238023a446f5371fa411883John McCall divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor); 19922cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner 1993913dab2525cc705e5238023a446f5371fa411883John McCall // For everything elese, we can just compute it, safe in the 1994913dab2525cc705e5238023a446f5371fa411883John McCall // assumption that Sema won't let anything through that we can't 1995913dab2525cc705e5238023a446f5371fa411883John McCall // safely compute the size of. 1996913dab2525cc705e5238023a446f5371fa411883John McCall } else { 1997913dab2525cc705e5238023a446f5371fa411883John McCall CharUnits elementSize; 1998913dab2525cc705e5238023a446f5371fa411883John McCall // Handle GCC extension for pointer arithmetic on void* and 1999913dab2525cc705e5238023a446f5371fa411883John McCall // function pointer types. 2000913dab2525cc705e5238023a446f5371fa411883John McCall if (elementType->isVoidType() || elementType->isFunctionType()) 2001913dab2525cc705e5238023a446f5371fa411883John McCall elementSize = CharUnits::One(); 2002913dab2525cc705e5238023a446f5371fa411883John McCall else 2003913dab2525cc705e5238023a446f5371fa411883John McCall elementSize = CGF.getContext().getTypeSizeInChars(elementType); 2004913dab2525cc705e5238023a446f5371fa411883John McCall 2005913dab2525cc705e5238023a446f5371fa411883John McCall // Don't even emit the divide for element size of 1. 2006913dab2525cc705e5238023a446f5371fa411883John McCall if (elementSize.isOne()) 2007913dab2525cc705e5238023a446f5371fa411883John McCall return diffInChars; 2008913dab2525cc705e5238023a446f5371fa411883John McCall 2009913dab2525cc705e5238023a446f5371fa411883John McCall divisor = CGF.CGM.getSize(elementSize); 2010913dab2525cc705e5238023a446f5371fa411883John McCall } 2011913dab2525cc705e5238023a446f5371fa411883John McCall 20122cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 20132cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // pointer difference in C is only defined in the case where both operands 20142cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // are pointing to elements of an array. 2015913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateExactSDiv(diffInChars, divisor, "sub.ptr.div"); 20167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 20187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 20197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 20207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 20217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 20227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 20237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 2024db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2025be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 2026be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 2027be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 2028be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 2029be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 2030be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 203115037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 2032be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 2033be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 2034be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 20357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateShl(Ops.LHS, RHS, "shl"); 20367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 20387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 20397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 20407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 20417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 20427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 20437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 2044db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2045be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 2046be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 2047be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 2048be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 2049be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 2050be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 205115037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 2052be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 2053be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 2054be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 2055f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasUnsignedIntegerRepresentation()) 20567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 20577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 20587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2060aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsevenum IntrinsicType { VCMPEQ, VCMPGT }; 2061aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev// return corresponding comparison intrinsic for given vector type 2062aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsevstatic llvm::Intrinsic::ID GetIntrinsic(IntrinsicType IT, 2063aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev BuiltinType::Kind ElemKind) { 2064aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev switch (ElemKind) { 2065aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev default: assert(0 && "unexpected element type"); 2066aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Char_U: 2067aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UChar: 2068aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 2069aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtub_p; 2070aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2071aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Char_S: 2072aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::SChar: 2073aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 2074aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsb_p; 2075aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2076aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UShort: 2077aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 2078aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtuh_p; 2079aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2080aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Short: 2081aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 2082aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsh_p; 2083aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2084aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UInt: 2085aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::ULong: 2086aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 2087aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtuw_p; 2088aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2089aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Int: 2090aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Long: 2091aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 2092aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsw_p; 2093aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2094aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Float: 2095aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p : 2096aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtfp_p; 2097aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2098aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2099aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return llvm::Intrinsic::not_intrinsic; 2100aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev} 2101aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 21027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 21037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc) { 21047f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 21054f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *Result; 21067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner QualType LHSTy = E->getLHS()->getType(); 21070bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) { 21082de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_EQ || 21092de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall E->getOpcode() == BO_NE); 2110d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *LHS = CGF.EmitScalarExpr(E->getLHS()); 2111d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *RHS = CGF.EmitScalarExpr(E->getRHS()); 21120bab0cdab751248ca389a5592bcb70eac5d39260John McCall Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison( 21132de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE); 2114b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else if (!LHSTy->isAnyComplexType()) { 21157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS = Visit(E->getLHS()); 21167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 2117db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2118aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // If AltiVec, the comparison results in a numeric type, so we use 2119aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // intrinsics comparing vectors and giving 0 or 1 as a result 21206305f721247f13707d9858b17d5696c1e3428a78Anton Yartsev if (LHSTy->isVectorType() && !E->getType()->isVectorType()) { 2121aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // constants for mapping CR6 register bits to predicate result 2122aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6; 2123aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2124aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ID ID = llvm::Intrinsic::not_intrinsic; 2125aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2126aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // in several cases vector arguments order will be reversed 2127aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Value *FirstVecArg = LHS, 2128aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev *SecondVecArg = RHS; 2129aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2130aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev QualType ElTy = LHSTy->getAs<VectorType>()->getElementType(); 2131f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const BuiltinType *BTy = ElTy->getAs<BuiltinType>(); 2132aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev BuiltinType::Kind ElementKind = BTy->getKind(); 2133aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2134aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev switch(E->getOpcode()) { 2135aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev default: assert(0 && "is not a comparison operation"); 2136aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_EQ: 2137aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2138aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPEQ, ElementKind); 2139aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2140aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_NE: 2141aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2142aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPEQ, ElementKind); 2143aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2144aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_LT: 2145aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2146aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2147aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2148aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2149aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_GT: 2150aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2151aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2152aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2153aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_LE: 2154aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (ElementKind == BuiltinType::Float) { 2155aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2156aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 2157aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2158aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2159aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev else { 2160aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2161aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2162aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2163aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2164aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_GE: 2165aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (ElementKind == BuiltinType::Float) { 2166aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2167aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 2168aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2169aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev else { 2170aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2171aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2172aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2173aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2174aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2175aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2176aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 217748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Value *CR6Param = Builder.getInt32(CR6); 2178aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Function *F = CGF.CGM.getIntrinsic(ID); 2179aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Result = Builder.CreateCall3(F, CR6Param, FirstVecArg, SecondVecArg, ""); 2180aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 2181aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2182aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2183f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (LHS->getType()->isFPOrFPVectorTy()) { 21847a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 21857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 2186f60946222721d9ba3c059563935c17b84703187aDouglas Gregor } else if (LHSTy->hasSignedIntegerRepresentation()) { 2187ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 21887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 21897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 2190ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman // Unsigned integers and pointers. 2191ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 21927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 21937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 21949c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner 21959c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // If this is a vector comparison, sign extend the result to the appropriate 21969c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // vector integer type and return it (don't convert to bool). 21979c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner if (LHSTy->isVectorType()) 21989c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 2199db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 22017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex Comparison: can only be an equality comparison. 22027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 22037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 2204db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2205183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType CETy = LHSTy->getAs<ComplexType>()->getElementType(); 2206db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22074f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *ResultR, *ResultI; 22087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (CETy->isRealFloatingType()) { 22097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 22107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 22117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 22127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 22137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 22147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex comparisons can only be equality comparisons. As such, signed 22157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // and unsigned opcodes are the same. 22167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 22177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 22187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 22197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 22207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2221db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22222de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (E->getOpcode() == BO_EQ) { 22237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 22247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 22252de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_NE && 22267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Complex comparison other than == or != ?"); 22277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 22287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 22297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 223032f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes 223132f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 22327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 22337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 22347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 22357f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool Ignore = TestAndClearIgnoreResultAssign(); 22367f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 2237f85e193739c953358c865005855253af4f68a497John McCall Value *RHS; 2238f85e193739c953358c865005855253af4f68a497John McCall LValue LHS; 2239f85e193739c953358c865005855253af4f68a497John McCall 2240f85e193739c953358c865005855253af4f68a497John McCall switch (E->getLHS()->getType().getObjCLifetime()) { 2241f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Strong: 2242f85e193739c953358c865005855253af4f68a497John McCall llvm::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore); 2243f85e193739c953358c865005855253af4f68a497John McCall break; 2244f85e193739c953358c865005855253af4f68a497John McCall 2245f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Autoreleasing: 2246f85e193739c953358c865005855253af4f68a497John McCall llvm::tie(LHS,RHS) = CGF.EmitARCStoreAutoreleasing(E); 2247f85e193739c953358c865005855253af4f68a497John McCall break; 2248f85e193739c953358c865005855253af4f68a497John McCall 2249f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Weak: 2250f85e193739c953358c865005855253af4f68a497John McCall RHS = Visit(E->getRHS()); 2251f85e193739c953358c865005855253af4f68a497John McCall LHS = EmitCheckedLValue(E->getLHS()); 2252f85e193739c953358c865005855253af4f68a497John McCall RHS = CGF.EmitARCStoreWeak(LHS.getAddress(), RHS, Ignore); 2253f85e193739c953358c865005855253af4f68a497John McCall break; 2254f85e193739c953358c865005855253af4f68a497John McCall 2255f85e193739c953358c865005855253af4f68a497John McCall // No reason to do any of these differently. 2256f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_None: 2257f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_ExplicitNone: 2258f85e193739c953358c865005855253af4f68a497John McCall // __block variables need to have the rhs evaluated first, plus 2259f85e193739c953358c865005855253af4f68a497John McCall // this should improve codegen just a little. 2260f85e193739c953358c865005855253af4f68a497John McCall RHS = Visit(E->getRHS()); 2261f85e193739c953358c865005855253af4f68a497John McCall LHS = EmitCheckedLValue(E->getLHS()); 2262f85e193739c953358c865005855253af4f68a497John McCall 2263f85e193739c953358c865005855253af4f68a497John McCall // Store the value into the LHS. Bit-fields are handled specially 2264f85e193739c953358c865005855253af4f68a497John McCall // because the result is altered by the store, i.e., [C99 6.5.16p1] 2265f85e193739c953358c865005855253af4f68a497John McCall // 'An assignment expression has the value of the left operand after 2266f85e193739c953358c865005855253af4f68a497John McCall // the assignment...'. 2267f85e193739c953358c865005855253af4f68a497John McCall if (LHS.isBitField()) 2268545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, &RHS); 2269f85e193739c953358c865005855253af4f68a497John McCall else 2270545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS); 2271f85e193739c953358c865005855253af4f68a497John McCall } 2272d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2273d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 22747f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 22757f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 2276d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2277b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 2278b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!CGF.getContext().getLangOptions().CPlusPlus) 2279b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return RHS; 2280b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 2281d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 2282119a1c6c4029d30cae7b31a2826aa0ff70d01668John McCall if (LHS.isPropertyRef()) 2283d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2284d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2285d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 2286d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 2287d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2288d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2289d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 2290545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return EmitLoadOfLValue(LHS); 22917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 22927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 22937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 22947804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 22957804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 229620eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 229720eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 && X, just emit X without inserting the control flow. 2298c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool LHSCondVal; 2299c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) { 2300c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (LHSCondVal) { // If we have 1 && X, just emit X. 23010946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 23027804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 23037804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 23040946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2305db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23067804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 230720eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 23087804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::Constant::getNullValue(ResTy); 23090946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2310db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23119615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 23129615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 231320eb09d562b80420a3328be789547af354bf3e36Chris Lattner 2314150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 2315150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2316f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is false, go to the failure (cont) block. 2317f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 2318f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2319f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2320f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be false. Start 2321f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 2322bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2, 23230032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2324f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2325f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 23263b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 2327db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2328150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 23297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 23307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2331150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2332db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 23347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2335f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2336f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2337f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 2338acd723666777b4ac1f79a97b6a300e6cf919d519Devang Patel if (CGF.getDebugInfo()) 2339acd723666777b4ac1f79a97b6a300e6cf919d519Devang Patel // There is no need to emit line number for unconditional branch. 2340acd723666777b4ac1f79a97b6a300e6cf919d519Devang Patel Builder.SetCurrentDebugLocation(llvm::DebugLoc()); 23417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 23427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2343db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 23457804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 23467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 23497804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 23507804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 235120eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 235220eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 || X, just emit X without inserting the control flow. 2353c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool LHSCondVal; 2354c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) { 2355c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (!LHSCondVal) { // If we have 0 || X, just emit X. 23560946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 23577804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 23587804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 23590946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2360db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23617804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 236220eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 23637804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::ConstantInt::get(ResTy, 1); 23640946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2365db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23669615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 23679615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 2368db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2369150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 2370150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2371f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is true, go to the success (cont) block. 2372f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 2373f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2374f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2375f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be true. Start 2376f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 2377bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2, 23780032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2379f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2380f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 23813b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 2382f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2383150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 238433da07db112f4877f6ab13e20db08b9bb86a0c2eAnders Carlsson 2385f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit the RHS condition as a bool value. 23867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 23877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2388db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2389150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2390db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 23927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2393db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2394f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2395f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 2396f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBlock(ContBlock); 23977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2398db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 24007804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 24017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 24027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 24037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 24042a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E->getLHS()); 2405a448fb2da03ece39978784793eea68760e8205a1Daniel Dunbar CGF.EnsureInsertPoint(); 24067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getRHS()); 24077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 24087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 24097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 24107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Other Operators 24117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 24127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 24139802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 24149802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// expression is cheap enough and side-effect-free enough to evaluate 24159802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// unconditionally instead of conditionally. This is used to convert control 24169802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// flow into selects in some cases. 2417df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stumpstatic bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 2418df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CodeGenFunction &CGF) { 2419f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne E = E->IgnoreParens(); 2420db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2421c6bea67efc38b075c401ebdb6ae97afa08cbb51dChris Lattner // Anything that is an integer or floating point constant is fine. 2422c6bea67efc38b075c401ebdb6ae97afa08cbb51dChris Lattner if (E->isConstantInitializer(CGF.getContext(), false)) 24239802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2424db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24259802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // Non-volatile automatic variables too, to get "cond ? X : Y" where 24269802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // X and Y are local variables. 24279802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 24289802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 2429df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (VD->hasLocalStorage() && !(CGF.getContext() 2430df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .getCanonicalType(VD->getType()) 2431df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .isVolatileQualified())) 24329802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2433db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24349802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return false; 24359802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner} 24369802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 24379802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 24387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter:: 243956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallVisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 24407f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 244156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 244256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // Bind the common expression if necessary. 244356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall CodeGenFunction::OpaqueValueMapping binding(CGF, E); 244456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 244556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *condExpr = E->getCond(); 244656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *lhsExpr = E->getTrueExpr(); 244756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *rhsExpr = E->getFalseExpr(); 244856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 244931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the condition constant folds and can be elided, try to avoid emitting 245031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the condition and the dead arm. 2451c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool CondExprBool; 2452c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) { 245356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *live = lhsExpr, *dead = rhsExpr; 2454c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (!CondExprBool) std::swap(live, dead); 2455db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 245631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the dead side doesn't have labels we need, and if the Live side isn't 245731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the gnu missing ?: extension (which we could handle, but don't bother 245831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // to), just emit the Live part. 245956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (!CGF.ContainsLabel(dead)) 246056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return Visit(live); 2461c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner } 2462db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24636155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // OpenCL: If the condition is a vector, we can treat this condition like 24646155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // the select function. 24656155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (CGF.getContext().getLangOptions().OpenCL 246656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall && condExpr->getType()->isVectorType()) { 246756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *CondV = CGF.EmitScalarExpr(condExpr); 246856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *LHS = Visit(lhsExpr); 246956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *RHS = Visit(rhsExpr); 24706155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 247156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall const llvm::Type *condType = ConvertType(condExpr->getType()); 24726155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::VectorType *vecTy = cast<llvm::VectorType>(condType); 24736155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24746155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman unsigned numElem = vecTy->getNumElements(); 24756155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::Type *elemType = vecTy->getElementType(); 24766155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24776155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman std::vector<llvm::Constant*> Zvals; 24786155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman for (unsigned i = 0; i < numElem; ++i) 247948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Zvals.push_back(llvm::ConstantInt::get(elemType, 0)); 24806155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24816155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *zeroVec = llvm::ConstantVector::get(Zvals); 24826155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec); 24836155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp = Builder.CreateSExt(TestMSB, 24846155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::VectorType::get(elemType, 24856155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman numElem), 24866155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman "sext"); 24876155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp2 = Builder.CreateNot(tmp); 24886155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24896155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // Cast float to int to perform ANDs if necessary. 24906155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *RHSTmp = RHS; 24916155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *LHSTmp = LHS; 24926155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman bool wasCast = false; 24936155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType()); 24946155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (rhsVTy->getElementType()->isFloatTy()) { 24956155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType()); 24966155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman LHSTmp = Builder.CreateBitCast(LHS, tmp->getType()); 24976155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman wasCast = true; 24986155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 24996155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 25006155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2); 25016155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp); 25026155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond"); 25036155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (wasCast) 25046155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman tmp5 = Builder.CreateBitCast(tmp5, RHS->getType()); 2505db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25066155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman return tmp5; 25076155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 25086155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 25099802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // If this is a really simple expression (like x ? 4 : 5), emit this as a 25109802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // select instead of as control flow. We can only do this if it is cheap and 2511531a550531c144a58438f187816abbf1879e1c4eChris Lattner // safe to evaluate the LHS and RHS unconditionally. 251256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (isCheapEnoughToEvaluateUnconditionally(lhsExpr, CGF) && 251356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall isCheapEnoughToEvaluateUnconditionally(rhsExpr, CGF)) { 251456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr); 251556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *LHS = Visit(lhsExpr); 251656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *RHS = Visit(rhsExpr); 25179802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 25189802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner } 2519db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2520be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 2521be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 25229615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 2523150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2524150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 252556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock); 2526fb6fa30a9b06670deb14f862dddbc49a12552939Anders Carlsson 25277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(LHSBlock); 2528150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 252956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Value *LHS = Visit(lhsExpr); 2530150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2531db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHSBlock = Builder.GetInsertBlock(); 2533150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall Builder.CreateBr(ContBlock); 2534db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 2536150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 253756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Value *RHS = Visit(rhsExpr); 2538150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2539db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2540150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall RHSBlock = Builder.GetInsertBlock(); 25417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 2542db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 254348daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman // If the LHS or RHS is a throw expression, it will be legitimately null. 254448daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!LHS) 254548daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return RHS; 254648daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!RHS) 254748daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return LHS; 2548db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Create a PHI node for the real part. 2550bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond"); 25517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(LHS, LHSBlock); 25527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHS, RHSBlock); 25537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return PN; 25547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 25557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 25567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 25577976932a1c256d447316ffac58e9821417725e34Eli Friedman return Visit(E->getChosenSubExpr(CGF.getContext())); 25587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 25597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 25602202bce80fc72d067cbe67dc1512f7b45351fd31Chris LattnerValue *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 25614fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 2562ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 2563ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 2564ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson // If EmitVAArg fails, we fall back to the LLVM instruction. 2565db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (!ArgPtr) 2566ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 2567ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 25687f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // FIXME Volatility. 2569ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateLoad(ArgPtr); 25707c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson} 25717c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 25726b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCallValue *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *block) { 25736b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall return CGF.EmitBlockLiteral(block); 2574df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump} 2575df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 257661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya LattnerValue *ScalarExprEmitter::VisitAsTypeExpr(AsTypeExpr *E) { 257761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Value *Src = CGF.EmitScalarExpr(E->getSrcExpr()); 257861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner const llvm::Type * DstTy = ConvertType(E->getDstType()); 257961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 258061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // Going from vec4->vec3 or vec3->vec4 is a special case and requires 258161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // a shuffle vector instead of a bitcast. 258261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner const llvm::Type *SrcTy = Src->getType(); 258361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if (isa<llvm::VectorType>(DstTy) && isa<llvm::VectorType>(SrcTy)) { 258461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner unsigned numElementsDst = cast<llvm::VectorType>(DstTy)->getNumElements(); 258561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner unsigned numElementsSrc = cast<llvm::VectorType>(SrcTy)->getNumElements(); 258661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if ((numElementsDst == 3 && numElementsSrc == 4) 258761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner || (numElementsDst == 4 && numElementsSrc == 3)) { 258861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 258961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 259061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // In the case of going from int4->float3, a bitcast is needed before 259161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // doing a shuffle. 259261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner const llvm::Type *srcElemTy = 259361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner cast<llvm::VectorType>(SrcTy)->getElementType(); 259461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner const llvm::Type *dstElemTy = 259561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner cast<llvm::VectorType>(DstTy)->getElementType(); 259661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 259761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if ((srcElemTy->isIntegerTy() && dstElemTy->isFloatTy()) 259861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner || (srcElemTy->isFloatTy() && dstElemTy->isIntegerTy())) { 259961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // Create a float type of the same size as the source or destination. 260061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner const llvm::VectorType *newSrcTy = llvm::VectorType::get(dstElemTy, 260161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner numElementsSrc); 260261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 260361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Src = Builder.CreateBitCast(Src, newSrcTy, "astypeCast"); 260461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner } 260561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 260661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner llvm::Value *UnV = llvm::UndefValue::get(Src->getType()); 260761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 260861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner llvm::SmallVector<llvm::Constant*, 3> Args; 260961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(Builder.getInt32(0)); 261061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(Builder.getInt32(1)); 261161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(Builder.getInt32(2)); 261261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 261361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if (numElementsDst == 4) 261461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(llvm::UndefValue::get( 261561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner llvm::Type::getInt32Ty(CGF.getLLVMContext()))); 261661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 261761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 261861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 261961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner return Builder.CreateShuffleVector(Src, UnV, Mask, "astype"); 262061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner } 262161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner } 262261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 262361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner return Builder.CreateBitCast(Src, DstTy, "astype"); 262461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner} 262561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 26267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 26277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Entry Point into this File 26287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 26297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2630db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitScalarExpr - Emit the computation of the specified expression of scalar 2631db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type, ignoring the result. 26327f79f9be5916c51c35da4f126b7c12596a101607Mike StumpValue *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 26337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E && !hasAggregateLLVMType(E->getType()) && 26347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Invalid scalar expression to emit"); 2635db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 26365de7a0e8800b89780e565c1013e566414f11546aDevang Patel if (isa<CXXDefaultArgExpr>(E)) 2637aa11289f754d220c9c155b68a4f84cdcfcefef6aDevang Patel disableDebugInfo(); 26385de7a0e8800b89780e565c1013e566414f11546aDevang Patel Value *V = ScalarExprEmitter(*this, IgnoreResultAssign) 26397f79f9be5916c51c35da4f126b7c12596a101607Mike Stump .Visit(const_cast<Expr*>(E)); 26405de7a0e8800b89780e565c1013e566414f11546aDevang Patel if (isa<CXXDefaultArgExpr>(E)) 2641aa11289f754d220c9c155b68a4f84cdcfcefef6aDevang Patel enableDebugInfo(); 26425de7a0e8800b89780e565c1013e566414f11546aDevang Patel return V; 26437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 26443707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 26453707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 26463707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 26474f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 26484f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 26493707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 26503707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner "Invalid scalar expression to emit"); 26513707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 26523707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 26534f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 2654db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 2655db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 2656db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 26574f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 26584f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, 26594f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 26609b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 26614f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner "Invalid complex -> scalar conversion"); 26624f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 26634f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner DstTy); 26644f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 2665cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 26668c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 26678c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *CodeGenFunction:: 26688c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 26698c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 26708c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre); 26718c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 26728c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2673820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz JahanianLValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 2674820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian llvm::Value *V; 2675820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // object->isa or (*object).isa 2676820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // Generate code as for: *(Class*)object 26775ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian // build Class* type 26785ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian const llvm::Type *ClassPtrTy = ConvertType(E->getType()); 26795ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian 2680820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Expr *BaseExpr = E->getBase(); 26817eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (BaseExpr->isRValue()) { 26825ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = CreateTempAlloca(ClassPtrTy, "resval"); 26835ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian llvm::Value *Src = EmitScalarExpr(BaseExpr); 26845ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian Builder.CreateStore(Src, V); 26859f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue( 2686545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall MakeAddrLValue(V, E->getType())); 26879f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar } else { 26889f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar if (E->isArrow()) 26899f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr); 26909f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar else 26919f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = EmitLValue(BaseExpr).getAddress(); 26925ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 2693820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 2694820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // build Class* type 2695820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian ClassPtrTy = ClassPtrTy->getPointerTo(); 2696820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian V = Builder.CreateBitCast(V, ClassPtrTy); 26979f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(V, E->getType()); 2698820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian} 2699820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 27006a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 27012a41637a995affa1563f4d82a8b026e326a2faa0John McCallLValue CodeGenFunction::EmitCompoundAssignmentLValue( 27026a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E) { 27036a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor ScalarExprEmitter Scalar(*this); 2704d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *Result = 0; 27056a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor switch (E->getOpcode()) { 27066a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#define COMPOUND_OP(Op) \ 27072de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_##Op##Assign: \ 27086a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 2709d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result) 27106a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Mul); 27116a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Div); 27126a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Rem); 27136a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Add); 27146a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Sub); 27156a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shl); 27166a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shr); 27176a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(And); 27186a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Xor); 27196a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Or); 27206a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#undef COMPOUND_OP 27216a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 27222de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemD: 27232de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemI: 27242de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 27252de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Div: 27262de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Rem: 27272de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 27282de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 27292de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shl: 27302de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shr: 27312de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LT: 27322de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GT: 27332de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LE: 27342de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GE: 27352de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_EQ: 27362de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_NE: 27372de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_And: 27382de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Xor: 27392de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Or: 27402de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LAnd: 27412de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LOr: 27422de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Assign: 27432de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Comma: 27446a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor assert(false && "Not valid compound assignment operators"); 27456a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor break; 27466a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor } 27476a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 27486a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor llvm_unreachable("Unhandled compound assignment operator"); 27496a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 2750