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 812acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner 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()); 156b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Stmt can't have complex result type!"); 1577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitExpr(Expr *S); 159f51dc64f90851f636302dbaaf3f52c0524cdac36Fariborz Jahanian 160af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *VisitParenExpr(ParenExpr *PE) { 161af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian return Visit(PE->getSubExpr()); 162af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian } 16391a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall Value *VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *E) { 16491a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall return Visit(E->getReplacement()); 16591a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall } 166f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne Value *VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 167f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne return Visit(GE->getResultExpr()); 168f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne } 1697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Leaves. 1717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitIntegerLiteral(const IntegerLiteral *E) { 17248431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt(E->getValue()); 1737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitFloatingLiteral(const FloatingLiteral *E) { 175bc0a2226c7fcd18b29b6846049e2cfcb872d3593Owen Anderson return llvm::ConstantFP::get(VMContext, E->getValue()); 1767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCharacterLiteral(const CharacterLiteral *E) { 1784a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 179e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman } 180e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 1814a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 1827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 183ed8abf18329df67b0abcbb3a10458bd8c1d2a595Douglas Gregor Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) { 184a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1857267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis } 1863f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson Value *VisitGNUNullExpr(const GNUNullExpr *E) { 187a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1883f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson } 1890027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Value *VisitOffsetOfExpr(OffsetOfExpr *E); 190f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne Value *VisitUnaryExprOrTypeTraitExpr(const UnaryExprOrTypeTraitExpr *E); 1910ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar Value *VisitAddrLabelExpr(const AddrLabelExpr *E) { 192d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel()); 193d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return Builder.CreateBitCast(V, ConvertType(E->getType())); 1940ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar } 195db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1969370c8f4af43a98a6f16e65f5d88d58db846e374Douglas Gregor Value *VisitSizeOfPackExpr(SizeOfPackExpr *E) { 19748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return llvm::ConstantInt::get(ConvertType(E->getType()),E->getPackLength()); 1989370c8f4af43a98a6f16e65f5d88d58db846e374Douglas Gregor } 199e996ffd240f20a1048179d7727a6ee3227261921John McCall 200e996ffd240f20a1048179d7727a6ee3227261921John McCall Value *VisitOpaqueValueExpr(OpaqueValueExpr *E) { 20156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (E->isGLValue()) 202545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E)); 203e996ffd240f20a1048179d7727a6ee3227261921John McCall 204e996ffd240f20a1048179d7727a6ee3227261921John McCall // Otherwise, assume the mapping is the scalar directly. 20556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return CGF.getOpaqueRValueMapping(E).getScalarVal(); 206e996ffd240f20a1048179d7727a6ee3227261921John McCall } 2079370c8f4af43a98a6f16e65f5d88d58db846e374Douglas Gregor 2087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // l-values. 2097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitDeclRefExpr(DeclRefExpr *E) { 21028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 211189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall if (!E->Evaluate(Result, CGF.getContext())) 212189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall return EmitLoadOfLValue(E); 213189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 214189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall assert(!Result.HasSideEffects && "Constant declref with side-effect?!"); 215189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 216189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall llvm::Constant *C; 21748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner if (Result.Val.isInt()) 21848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner C = Builder.getInt(Result.Val.getInt()); 21948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner else if (Result.Val.isFloat()) 220189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall C = llvm::ConstantFP::get(VMContext, Result.Val.getFloat()); 22148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner else 222189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall return EmitLoadOfLValue(E); 223189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 224189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall // Make sure we emit a debug reference to the global variable. 225189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) { 226189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall if (!CGF.getContext().DeclMustBeEmitted(VD)) 227189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall CGF.EmitDeclRefExprDbgValue(E, C); 228189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall } else if (isa<EnumConstantDecl>(E->getDecl())) { 229189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall CGF.EmitDeclRefExprDbgValue(E, C); 230189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall } 231189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 232189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall return C; 2337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 234db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 235db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCSelectorExpr(E); 2369c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 237db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 238db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCProtocolExpr(E); 2399c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 240db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 2419c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return EmitLoadOfLValue(E); 2429c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 2430a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 244f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(E->getObjectKind() == OK_Ordinary && 245f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall "reached property reference without lvalue-to-rvalue"); 24685c59edda02df48fae8dc85049743319bc6e7e89Daniel Dunbar return EmitLoadOfLValue(E); 2479c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 2489c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar Value *VisitObjCMessageExpr(ObjCMessageExpr *E) { 249180ff3ac073c86bf7b5dbf48cfdfb7fc8252ce5fFariborz Jahanian if (E->getMethodDecl() && 250180ff3ac073c86bf7b5dbf48cfdfb7fc8252ce5fFariborz Jahanian E->getMethodDecl()->getResultType()->isReferenceType()) 251180ff3ac073c86bf7b5dbf48cfdfb7fc8252ce5fFariborz Jahanian return EmitLoadOfLValue(E); 2529c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return CGF.EmitObjCMessageExpr(E).getScalarVal(); 2530a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar } 2540a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar 25583dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian Value *VisitObjCIsaExpr(ObjCIsaExpr *E) { 256820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian LValue LV = CGF.EmitObjCIsaExpr(E); 257545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall Value *V = CGF.EmitLoadOfLValue(LV).getScalarVal(); 25883dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian return V; 25983dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian } 26083dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian 2617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 262d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E); 26328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Value *VisitMemberExpr(MemberExpr *E); 264213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); } 265be20bb558cae5352898e6a913e29d24d20134841Chris Lattner Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 266be20bb558cae5352898e6a913e29d24d20134841Chris Lattner return EmitLoadOfLValue(E); 267be20bb558cae5352898e6a913e29d24d20134841Chris Lattner } 26835634f5ed67966c9f1fde38420e79cc6515cd673Devang Patel 2690533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *VisitInitListExpr(InitListExpr *E); 270db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2713498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) { 2723cb18bcefe39756f3b079fa1a62b4c9cbf6a592fAnders Carlsson return CGF.CGM.EmitNullConstant(E->getType()); 2733498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor } 274bc8d40d85f3fa1e34569834916f18fecaa635152John McCall Value *VisitExplicitCastExpr(ExplicitCastExpr *E) { 275745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (E->getType()->isVariablyModifiedType()) 276bc8d40d85f3fa1e34569834916f18fecaa635152John McCall CGF.EmitVariablyModifiedType(E->getType()); 277bc8d40d85f3fa1e34569834916f18fecaa635152John McCall return VisitCastExpr(E); 2787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 279bc8d40d85f3fa1e34569834916f18fecaa635152John McCall Value *VisitCastExpr(CastExpr *E); 2807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCallExpr(const CallExpr *E) { 282e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson if (E->getCallReturnType()->isReferenceType()) 283e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson return EmitLoadOfLValue(E); 284db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2859b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitCallExpr(E).getScalarVal(); 2867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2878f2926b73ed635afecd020da787af6a837601a2bDaniel Dunbar 2883379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner Value *VisitStmtExpr(const StmtExpr *E); 2894e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump 290a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike Stump Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E); 291db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Unary Operators. 2937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostDec(const UnaryOperator *E) { 2948c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2958c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, false); 2967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostInc(const UnaryOperator *E) { 2988c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2998c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, false); 3007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreDec(const UnaryOperator *E) { 3028c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 3038c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, true); 3047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreInc(const UnaryOperator *E) { 3068c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 3078c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, true); 3087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3098c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 310683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *EmitAddConsiderOverflowBehavior(const UnaryOperator *E, 311683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *InVal, 312683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *NextVal, 313683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev bool IsInc); 314683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 3158c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 3168c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre); 3178c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 3188c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 3197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryAddrOf(const UnaryOperator *E) { 3205808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall if (isa<MemberPointerType>(E->getType())) // never sugared 3215808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall return CGF.CGM.getMemberPointerConstant(E); 3225808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall 3237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLValue(E->getSubExpr()).getAddress(); 3247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 325fd569004b78124c1041feee75a1e311166268c8dJohn McCall Value *VisitUnaryDeref(const UnaryOperator *E) { 326fd569004b78124c1041feee75a1e311166268c8dJohn McCall if (E->getType()->isVoidType()) 327fd569004b78124c1041feee75a1e311166268c8dJohn McCall return Visit(E->getSubExpr()); // the actual value should be unused 328fd569004b78124c1041feee75a1e311166268c8dJohn McCall return EmitLoadOfLValue(E); 329fd569004b78124c1041feee75a1e311166268c8dJohn McCall } 3307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPlus(const UnaryOperator *E) { 3317f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // This differs from gcc, though, most likely due to a bug in gcc. 3327f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 3337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 3347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryMinus (const UnaryOperator *E); 3367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryNot (const UnaryOperator *E); 3377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryLNot (const UnaryOperator *E); 33846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryReal (const UnaryOperator *E); 33946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryImag (const UnaryOperator *E); 3407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryExtension(const UnaryOperator *E) { 3417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 3427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3438ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 3445f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson // C++ 3453f86ce1dc64a46d9cd3675787b8af32c9158abe6Douglas Gregor Value *VisitMaterializeTemporaryExpr(const MaterializeTemporaryExpr *E) { 346ec24b0ed9ccf8b34986eadeb98dd0b4a0a50f6f2Eli Friedman return EmitLoadOfLValue(E); 3473f86ce1dc64a46d9cd3675787b8af32c9158abe6Douglas Gregor } 3483f86ce1dc64a46d9cd3675787b8af32c9158abe6Douglas Gregor 34904421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 35004421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 35104421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 3525f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson Value *VisitCXXThisExpr(CXXThisExpr *TE) { 3535f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson return CGF.LoadCXXThis(); 354db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 355db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3564765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall Value *VisitExprWithCleanups(ExprWithCleanups *E) { 3574765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall return CGF.EmitExprWithCleanups(E).getScalarVal(); 3587f6ad153565245026c7569314f65a4d4ff4ac41fAnders Carlsson } 359a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson Value *VisitCXXNewExpr(const CXXNewExpr *E) { 360a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson return CGF.EmitCXXNewExpr(E); 361a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson } 36260e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) { 36360e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson CGF.EmitCXXDeleteExpr(E); 36460e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson return 0; 36560e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson } 3669dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman Value *VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 36748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt1(E->getValue()); 3689dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman } 369db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3706ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet Value *VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *E) { 371f187237d916afa97c491ac32fe98be7d335c5b63Francois Pichet return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 3726ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet } 3736ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet 37421ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley Value *VisitArrayTypeTraitExpr(const ArrayTypeTraitExpr *E) { 37521ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley return llvm::ConstantInt::get(Builder.getInt32Ty(), E->getValue()); 37621ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley } 37721ff2e516b0e0bc8c1dbf965cb3d44bac3c64330John Wiegley 378552622067dc45013d240f73952fece703f5e63bdJohn Wiegley Value *VisitExpressionTraitExpr(const ExpressionTraitExpr *E) { 379552622067dc45013d240f73952fece703f5e63bdJohn Wiegley return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue()); 380552622067dc45013d240f73952fece703f5e63bdJohn Wiegley } 381552622067dc45013d240f73952fece703f5e63bdJohn Wiegley 382a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) { 383a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // C++ [expr.pseudo]p1: 384db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // The result shall only be used as the operand for the function call 385a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // operator (), and the result of such a call has type void. The only 386a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // effect is the evaluation of the postfix-expression before the dot or 387a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // arrow. 388a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor CGF.EmitScalarExpr(E->getBase()); 389a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor return 0; 390a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor } 391db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 392c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 393a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 394c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson } 395756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 396756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson Value *VisitCXXThrowExpr(const CXXThrowExpr *E) { 397756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson CGF.EmitCXXThrowExpr(E); 398756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson return 0; 399756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson } 400756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 40198294def01c97e127fa6d812ebd944d37212828aSebastian Redl Value *VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) { 40248431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt1(E->getValue()); 40398294def01c97e127fa6d812ebd944d37212828aSebastian Redl } 40498294def01c97e127fa6d812ebd944d37212828aSebastian Redl 4057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Binary Operators. 4067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitMul(const BinOpInfo &Ops) { 407575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (Ops.Ty->isSignedIntegerOrEnumerationType()) { 408a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 409a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 410a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul"); 411a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 412a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 413a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 414a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 415a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 416a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 417a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 418f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 41987415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul"); 4207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 4217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4228023030f76d334355b73d9c675d3870858aaf4fdChris Lattner bool isTrapvOverflowBehavior() { 4238023030f76d334355b73d9c675d3870858aaf4fdChris Lattner return CGF.getContext().getLangOptions().getSignedOverflowBehavior() 4248023030f76d334355b73d9c675d3870858aaf4fdChris Lattner == LangOptions::SOB_Trapping; 4258023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 4262add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Create a binary op that checks for overflow. 4272add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Currently only supports +, - and *. 4282add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); 4298023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Emit the overflow BB when -ftrapv option is activated. 4308023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitOverflowBB(llvm::BasicBlock *overflowBB) { 4318023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(overflowBB); 4328023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Function *Trap = CGF.CGM.getIntrinsic(llvm::Intrinsic::trap); 4338023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCall(Trap); 4348023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateUnreachable(); 4358023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 4368023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Check for undefined division and modulus behaviors. 4378023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops, 4388023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero,bool isDiv); 4397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitDiv(const BinOpInfo &Ops); 4407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitRem(const BinOpInfo &Ops); 4417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAdd(const BinOpInfo &Ops); 4427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitSub(const BinOpInfo &Ops); 4437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShl(const BinOpInfo &Ops); 4447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShr(const BinOpInfo &Ops); 4457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAnd(const BinOpInfo &Ops) { 4467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 4477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitXor(const BinOpInfo &Ops) { 4497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 4507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitOr (const BinOpInfo &Ops) { 4527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 4537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4551f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo EmitBinOps(const BinaryOperator *E); 4566a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 4576a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*F)(const BinOpInfo &), 458d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result); 4596a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 4603ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *EmitCompoundAssign(const CompoundAssignOperator *E, 4611f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 4621f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 4631f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Binary operators and binary compound assignment operators. 4641f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#define HANDLEBINOP(OP) \ 4653ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP(const BinaryOperator *E) { \ 4663ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return Emit ## OP(EmitBinOps(E)); \ 4673ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner } \ 4683ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 4693ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 4701f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 4717177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Mul) 4727177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Div) 4737177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Rem) 4747177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Add) 4757177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Sub) 4767177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shl) 4777177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shr) 4787177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(And) 4797177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Xor) 4807177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Or) 4811f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#undef HANDLEBINOP 4828c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 4837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Comparisons. 4847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 4857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc); 4867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#define VISITCOMP(CODE, UI, SI, FP) \ 4877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBin##CODE(const BinaryOperator *E) { \ 4887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 4897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::FCmpInst::FP); } 4907177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT) 4917177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT) 4927177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE) 4937177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE) 4947177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ) 4957177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE) 4967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#undef VISITCOMP 497db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinAssign (const BinaryOperator *E); 4997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLAnd (const BinaryOperator *E); 5017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLOr (const BinaryOperator *E); 5027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinComma (const BinaryOperator *E); 5037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 50425b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); } 50525b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); } 50625b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman 5077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Other Operators. 508df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump Value *VisitBlockExpr(const BlockExpr *BE); 50956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Value *VisitAbstractConditionalOperator(const AbstractConditionalOperator *); 5107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitChooseExpr(ChooseExpr *CE); 5117c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson Value *VisitVAArgExpr(VAArgExpr *VE); 5127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 5137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return CGF.EmitObjCStringLiteral(E); 5147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 51561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Value *VisitAsTypeExpr(AsTypeExpr *CE); 516276b061970939293f1abaf694bd3ef05b2cbda79Eli Friedman Value *VisitAtomicExpr(AtomicExpr *AE); 5177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 5187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} // end anonymous namespace. 5197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Utilities 5227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5249abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner/// EmitConversionToBool - Convert the specified expression value to a 5253420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner/// boolean (i1) truth value. This is equivalent to "Val != 0". 5269abc84e7ac4db891209fe67cc3a8c9690dc886efChris LattnerValue *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 527467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs"); 528db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 529daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (SrcType->isRealFloatingType()) 530daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitFloatToBoolConversion(Src); 531db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5320bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType)) 5330bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT); 534db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 535d1d66bcd6914ff82abdfa88dd25bb0b74cde3b99Daniel Dunbar assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 5369abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner "Unknown scalar type to convert"); 537db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 538daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (isa<llvm::IntegerType>(Src->getType())) 539daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitIntToBoolConversion(Src); 540db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 541daa8e4e888758d55a7a759dd4a91b83921cef222John McCall assert(isa<llvm::PointerType>(Src->getType())); 542daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitPointerToBoolConversion(Src); 5439abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner} 5449abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 5453707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 5463707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 5474f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 5484f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstType) { 5499619662a1d42e2008b865d3459c0677e149dad1bChris Lattner SrcType = CGF.getContext().getCanonicalType(SrcType); 5509619662a1d42e2008b865d3459c0677e149dad1bChris Lattner DstType = CGF.getContext().getCanonicalType(DstType); 5513707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (SrcType == DstType) return Src; 552db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 553cf289083ab007264fa3ea96d92f133339aee5d2dChris Lattner if (DstType->isVoidType()) return 0; 554db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 555aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov llvm::Type *SrcTy = Src->getType(); 556aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 557aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov // Floating casts might be a bit special: if we're doing casts to / from half 558aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov // FP, we should go via special intrinsics. 559aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov if (SrcType->isHalfType()) { 560aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Src = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16), Src); 561aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov SrcType = CGF.getContext().FloatTy; 562aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov SrcTy = llvm::Type::getFloatTy(VMContext); 563aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov } 564aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 5653707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 566ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstType->isBooleanType()) 567ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return EmitConversionToBool(Src, SrcType); 568db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5692acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *DstTy = ConvertType(DstType); 5703707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 5713707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Ignore conversions like int -> uint. 572aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov if (SrcTy == DstTy) 5733707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Src; 5743707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 575db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle pointer conversions next: pointers can only be converted to/from 576db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // other pointers and integers. Check for pointer types in terms of LLVM, as 577db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // some native types (like Obj-C id) may map to a pointer type. 578270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(DstTy)) { 5793707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // The source value may be an integer, or a pointer. 580aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov if (isa<llvm::PointerType>(SrcTy)) 5813707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Builder.CreateBitCast(Src, DstTy, "conv"); 582191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 5833707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 58425615424741bcce31fe52c896f76268f0307f00dEli Friedman // First, convert to the correct width so that we control the kind of 58525615424741bcce31fe52c896f76268f0307f00dEli Friedman // extension. 5862acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *MiddleTy = CGF.IntPtrTy; 587575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool InputSigned = SrcType->isSignedIntegerOrEnumerationType(); 58825615424741bcce31fe52c896f76268f0307f00dEli Friedman llvm::Value* IntResult = 58925615424741bcce31fe52c896f76268f0307f00dEli Friedman Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 59025615424741bcce31fe52c896f76268f0307f00dEli Friedman // Then, cast to pointer. 59125615424741bcce31fe52c896f76268f0307f00dEli Friedman return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 5923707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 593db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 594aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov if (isa<llvm::PointerType>(SrcTy)) { 5953707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Must be an ptr to int cast. 5963707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 59750b5a30db40322880340e957ad7d6d8d60bb4c5bAnders Carlsson return Builder.CreatePtrToInt(Src, DstTy, "conv"); 5983707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 599db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 600213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // A scalar can be splatted to an extended vector of the same element type 6012ef13e5abef0570a9f567b4671367275c05d4d34Nate Begeman if (DstType->isExtVectorType() && !SrcType->isVectorType()) { 6026fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Cast the scalar to element type 603183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType EltTy = DstType->getAs<ExtVectorType>()->getElementType(); 6046fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 6056fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 6066fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Insert the element in element zero of an undef vector 60703e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::Value *UnV = llvm::UndefValue::get(DstTy); 60848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *Idx = Builder.getInt32(0); 609578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer UnV = Builder.CreateInsertElement(UnV, Elt, Idx); 6106fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 6116fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Splat the element across to all elements 6125f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant*, 16> Args; 6136fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 614fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner for (unsigned i = 0; i != NumElements; ++i) 61548431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(0)); 616db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 617fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 6186fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 6196fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman return Yay; 6206fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman } 6214119d1aeca8016654d381ce079864058d1709571Nate Begeman 6223b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner // Allow bitcast from vector to integer/fp of the same size. 623aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov if (isa<llvm::VectorType>(SrcTy) || 6243b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner isa<llvm::VectorType>(DstTy)) 6257019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson return Builder.CreateBitCast(Src, DstTy, "conv"); 626db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 6273707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Finally, we have the arithmetic types: real int/float. 628aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Value *Res = NULL; 629aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov llvm::Type *ResTy = DstTy; 630aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 631aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov // Cast to half via float 632aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov if (DstType->isHalfType()) 633aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov DstTy = llvm::Type::getFloatTy(VMContext); 634aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 635aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov if (isa<llvm::IntegerType>(SrcTy)) { 636575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool InputSigned = SrcType->isSignedIntegerOrEnumerationType(); 637b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (isa<llvm::IntegerType>(DstTy)) 638aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Res = Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 639b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else if (InputSigned) 640aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Res = Builder.CreateSIToFP(Src, DstTy, "conv"); 641b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 642aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Res = Builder.CreateUIToFP(Src, DstTy, "conv"); 643aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov } else if (isa<llvm::IntegerType>(DstTy)) { 644aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov assert(SrcTy->isFloatingPointTy() && "Unknown real conversion"); 645575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (DstType->isSignedIntegerOrEnumerationType()) 646aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Res = Builder.CreateFPToSI(Src, DstTy, "conv"); 647aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov else 648aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Res = Builder.CreateFPToUI(Src, DstTy, "conv"); 649aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov } else { 650aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov assert(SrcTy->isFloatingPointTy() && DstTy->isFloatingPointTy() && 651aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov "Unknown real conversion"); 652aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov if (DstTy->getTypeID() < SrcTy->getTypeID()) 653aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Res = Builder.CreateFPTrunc(Src, DstTy, "conv"); 654b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 655aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Res = Builder.CreateFPExt(Src, DstTy, "conv"); 6563707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 6573707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 658aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov if (DstTy != ResTy) { 659aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov assert(ResTy->isIntegerTy(16) && "Only half FP requires extra conversion"); 660aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Res = Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16), Res); 661aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov } 662aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 663aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov return Res; 6643707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 6653707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 666db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 667db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 668db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 6694f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter:: 6704f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerEmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 6714f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy) { 672ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Get the source element type. 673183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall SrcTy = SrcTy->getAs<ComplexType>()->getElementType(); 674db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 675ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 676ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstTy->isBooleanType()) { 677ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Complex != 0 -> (Real != 0) | (Imag != 0) 678ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 679ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 680ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return Builder.CreateOr(Src.first, Src.second, "tobool"); 681ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner } 682db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 6834f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 6844f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // the imaginary part of the complex value is discarded and the value of the 6854f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // real part is converted according to the conversion rules for the 686db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // corresponding real type. 6874f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return EmitScalarConversion(Src.first, SrcTy, DstTy); 6884f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 6894f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 690a40a9f31218c743e366322e34b59f0d4d4414198Anders CarlssonValue *ScalarExprEmitter::EmitNullValue(QualType Ty) { 6910bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) 6920bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 6930bab0cdab751248ca389a5592bcb70eac5d39260John McCall 6940bab0cdab751248ca389a5592bcb70eac5d39260John McCall return llvm::Constant::getNullValue(ConvertType(Ty)); 695a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson} 6964f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 6977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Visitor Methods 6997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 7007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 7017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitExpr(Expr *E) { 702488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGF.ErrorUnsupported(E, "scalar expression"); 7037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getType()->isVoidType()) 7047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 70503e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 7067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 7077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 708d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanValue *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 70937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Vector Mask Case 71037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 2 || 7113f4cb120fe574f7b80864f52a1999502a4f3a83dRafael Espindola (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { 71277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *LHS = CGF.EmitScalarExpr(E->getExpr(0)); 71377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *RHS = CGF.EmitScalarExpr(E->getExpr(1)); 71477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Mask; 71537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 7162acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType()); 71737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman unsigned LHSElts = LTy->getNumElements(); 71837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 71937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 3) { 72037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = CGF.EmitScalarExpr(E->getExpr(2)); 72137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 72237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Shuffle LHS & RHS into one input vector. 7235f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant*, 32> concat; 72437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0; i != LHSElts; ++i) { 72548431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner concat.push_back(Builder.getInt32(2*i)); 72648431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner concat.push_back(Builder.getInt32(2*i+1)); 72737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 72837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 729fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner Value* CV = llvm::ConstantVector::get(concat); 73037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); 73137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHSElts *= 2; 73237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } else { 73337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = RHS; 73437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 73537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 7362acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType()); 73737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant* EltMask; 73837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 73937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Treat vec3 like vec4. 74037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) 74137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 74237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+2))-1); 74337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else if ((LHSElts == 3) && (E->getNumSubExprs() == 2)) 74437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 74537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+1))-1); 74637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else 74737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 74837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts))-1); 74937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 75037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Mask off the high bits of each shuffle index. 7515f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant *, 32> MaskV; 75237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) 75337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MaskV.push_back(EltMask); 75437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 755fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner Value* MaskBits = llvm::ConstantVector::get(MaskV); 75637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); 75737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 75837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = undef 75937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // mask = mask & maskbits 76037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // for each elt 76137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // n = extract mask i 76237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // x = extract val n 76337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = insert newv, x, i 7642acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(), 76537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MTy->getNumElements()); 76637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* NewV = llvm::UndefValue::get(RTy); 76737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) { 76848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Value *Indx = Builder.getInt32(i); 76937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateExtractElement(Mask, Indx, "shuf_idx"); 77077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext"); 77137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 77237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 77337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { 77437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *cmpIndx, *newIndx; 77548431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner cmpIndx = Builder.CreateICmpUGT(Indx, Builder.getInt32(3), 77637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "cmp_shuf_idx"); 77748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner newIndx = Builder.CreateSub(Indx, Builder.getInt32(1), "shuf_idx_adj"); 77837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx"); 77937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 78037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt"); 78137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman NewV = Builder.CreateInsertElement(NewV, VExt, Indx, "shuf_ins"); 78237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 78337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman return NewV; 784d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 78537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 786d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 787d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 78837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 78937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 7902acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::VectorType *VTy = cast<llvm::VectorType>(V1->getType()); 7915f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant*, 32> indices; 79237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 7930eb47fc01849a94bac7fda236134f9301eff688bEli Friedman unsigned Idx = E->getShuffleMaskIdx(CGF.getContext(), i-2); 7940eb47fc01849a94bac7fda236134f9301eff688bEli Friedman if (VTy->getNumElements() == 3 && Idx > 3) 7950eb47fc01849a94bac7fda236134f9301eff688bEli Friedman Idx -= 1; 7960eb47fc01849a94bac7fda236134f9301eff688bEli Friedman indices.push_back(Builder.getInt32(Idx)); 79737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 79837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 799fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner Value *SV = llvm::ConstantVector::get(indices); 800d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 801d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 80228665272c36cccb1014a6ea1217354b0519e2b59Eli FriedmanValue *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) { 80328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 80428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 80528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->isArrow()) 80628665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman CGF.EmitScalarExpr(E->getBase()); 80728665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman else 80828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman EmitLValue(E->getBase()); 80948431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt(Result.Val.getInt()); 81028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 81178ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel 81278ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // Emit debug info for aggregate now, if it was delayed to reduce 81378ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // debug info size. 81478ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel CGDebugInfo *DI = CGF.getDebugInfo(); 81578ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (DI && CGF.CGM.getCodeGenOpts().LimitDebugInfo) { 81678ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel QualType PQTy = E->getBase()->IgnoreParenImpCasts()->getType(); 81778ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (const PointerType * PTy = dyn_cast<PointerType>(PQTy)) 81849c8465f14fc3b2e1a32c7016ad3fb4e2cf8d466Devang Patel if (FieldDecl *M = dyn_cast<FieldDecl>(E->getMemberDecl())) 81978ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel DI->getOrCreateRecordType(PTy->getPointeeType(), 82078ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel M->getParent()->getLocation()); 8217fa8ab2e77f5703d0adf14e4d98f1edc1e66505dDevang Patel } 82228665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return EmitLoadOfLValue(E); 82328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman} 824d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 8257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 8267f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 8277f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 8287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Emit subscript expressions in rvalue context's. For most cases, this just 8297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // loads the lvalue formed by the subscript expr. However, we have to be 8307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // careful, because the base of a vector subscript is occasionally an rvalue, 8317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // so we can't get it as an lvalue. 8327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (!E->getBase()->getType()->isVectorType()) 8337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 834db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 8357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the vector case. The base must be a vector, the index must be an 8367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // integer value. 8377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Base = Visit(E->getBase()); 8387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Idx = Visit(E->getIdx()); 839575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool IdxSigned = E->getIdx()->getType()->isSignedIntegerOrEnumerationType(); 84077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast"); 8417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateExtractElement(Base, Idx, "vecext"); 8427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 8437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 8440533b3020ca39898751d4200feed776861dcd1ceNate Begemanstatic llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, 8452acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner unsigned Off, llvm::Type *I32Ty) { 8460533b3020ca39898751d4200feed776861dcd1ceNate Begeman int MV = SVI->getMaskValue(Idx); 8470533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (MV == -1) 8480533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::UndefValue::get(I32Ty); 8490533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::ConstantInt::get(I32Ty, Off+MV); 8500533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 8510533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8520533b3020ca39898751d4200feed776861dcd1ceNate BegemanValue *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { 8530533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool Ignore = TestAndClearIgnoreResultAssign(); 8540533b3020ca39898751d4200feed776861dcd1ceNate Begeman (void)Ignore; 8550533b3020ca39898751d4200feed776861dcd1ceNate Begeman assert (Ignore == false && "init list ignored"); 8560533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned NumInitElements = E->getNumInits(); 8570533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8580533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (E->hadArrayRangeDesignator()) 8590533b3020ca39898751d4200feed776861dcd1ceNate Begeman CGF.ErrorUnsupported(E, "GNU array range designator extension"); 8600533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8612acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::VectorType *VType = 8620533b3020ca39898751d4200feed776861dcd1ceNate Begeman dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 8630533b3020ca39898751d4200feed776861dcd1ceNate Begeman 864cea8d966f826554f0679595e9371e314e8dbc1cfSebastian Redl if (!VType) { 865cea8d966f826554f0679595e9371e314e8dbc1cfSebastian Redl if (NumInitElements == 0) { 866cea8d966f826554f0679595e9371e314e8dbc1cfSebastian Redl // C++11 value-initialization for the scalar. 867cea8d966f826554f0679595e9371e314e8dbc1cfSebastian Redl return EmitNullValue(E->getType()); 868cea8d966f826554f0679595e9371e314e8dbc1cfSebastian Redl } 869cea8d966f826554f0679595e9371e314e8dbc1cfSebastian Redl // We have a scalar in braces. Just use the first element. 8700533b3020ca39898751d4200feed776861dcd1ceNate Begeman return Visit(E->getInit(0)); 871cea8d966f826554f0679595e9371e314e8dbc1cfSebastian Redl } 8720533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8730533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned ResElts = VType->getNumElements(); 8740533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8750533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Loop over initializers collecting the Value for each, and remembering 8760533b3020ca39898751d4200feed776861dcd1ceNate Begeman // whether the source was swizzle (ExtVectorElementExpr). This will allow 8770533b3020ca39898751d4200feed776861dcd1ceNate Begeman // us to fold the shuffle for the swizzle into the shuffle for the vector 8780533b3020ca39898751d4200feed776861dcd1ceNate Begeman // initializer, since LLVM optimizers generally do not want to touch 8790533b3020ca39898751d4200feed776861dcd1ceNate Begeman // shuffles. 8800533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned CurIdx = 0; 8810533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool VIsUndefShuffle = false; 8820533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *V = llvm::UndefValue::get(VType); 8830533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned i = 0; i != NumInitElements; ++i) { 8840533b3020ca39898751d4200feed776861dcd1ceNate Begeman Expr *IE = E->getInit(i); 8850533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Init = Visit(IE); 8865f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant*, 16> Args; 8870533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8882acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType()); 8890533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8900533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Handle scalar elements. If the scalar initializer is actually one 8910533b3020ca39898751d4200feed776861dcd1ceNate Begeman // element of a different vector of the same width, use shuffle instead of 8920533b3020ca39898751d4200feed776861dcd1ceNate Begeman // extract+insert. 8930533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VVT) { 8940533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 8950533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init); 8960533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8970533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (EI->getVectorOperandType()->getNumElements() == ResElts) { 8980533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand()); 8990533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *LHS = 0, *RHS = 0; 9000533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) { 9010533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undef -> shuffle (src, undef) 9020533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(C); 9030533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 1; j != ResElts; ++j) 90477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9050533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9060533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = EI->getVectorOperand(); 9070533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = V; 9080533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = true; 9090533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else if (VIsUndefShuffle) { 9100533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undefshuffle && size match -> shuffle (v, src) 9110533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V); 9120533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 91377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty)); 91448431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(ResElts + C->getZExtValue())); 9150533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + 1; j != ResElts; ++j) 91677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9170533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9180533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 9190533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = EI->getVectorOperand(); 9200533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 9210533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9220533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!Args.empty()) { 923fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 9240533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(LHS, RHS, Mask); 9250533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 9260533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 9270533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9280533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9290533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 93048431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner V = Builder.CreateInsertElement(V, Init, Builder.getInt32(CurIdx), 93148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner "vecinit"); 9320533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 9330533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 9340533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 9350533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9360533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9370533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned InitElts = VVT->getNumElements(); 9380533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9390533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's 9400533b3020ca39898751d4200feed776861dcd1ceNate Begeman // input is the same width as the vector being constructed, generate an 9410533b3020ca39898751d4200feed776861dcd1ceNate Begeman // optimized shuffle of the swizzle input into the result. 942a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman unsigned Offset = (CurIdx == 0) ? 0 : ResElts; 9430533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 9440533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init); 9450533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *SVOp = SVI->getOperand(0); 9462acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType()); 9470533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9480533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (OpTy->getNumElements() == ResElts) { 9490533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) { 9500533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the current vector initializer is a shuffle with undef, merge 9510533b3020ca39898751d4200feed776861dcd1ceNate Begeman // this shuffle directly into it. 9520533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) { 9530533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0, 95477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner CGF.Int32Ty)); 9550533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else { 95648431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j)); 9570533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9580533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9590533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0, je = InitElts; j != je; ++j) 96077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty)); 9610533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 96277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9630533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9640533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) 9650533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 9660533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9670533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = SVOp; 9680533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9690533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9700533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9710533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Extend init to result vector length, and then shuffle its contribution 9720533b3020ca39898751d4200feed776861dcd1ceNate Begeman // to the vector initializer into V. 9730533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (Args.empty()) { 9740533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 97548431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j)); 9760533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = InitElts; j != ResElts; ++j) 97777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 978fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 9790533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), 980a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman Mask, "vext"); 9810533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9820533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.clear(); 9830533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 98448431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j)); 9850533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 98648431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Args.push_back(Builder.getInt32(j+Offset)); 9870533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 98877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9890533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9900533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9910533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If V is undef, make sure it ends up on the RHS of the shuffle to aid 9920533b3020ca39898751d4200feed776861dcd1ceNate Begeman // merging subsequent shuffles into this one. 9930533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) 9940533b3020ca39898751d4200feed776861dcd1ceNate Begeman std::swap(V, Init); 995fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 9960533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit"); 9970533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = isa<llvm::UndefValue>(Init); 9980533b3020ca39898751d4200feed776861dcd1ceNate Begeman CurIdx += InitElts; 9990533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 10000533b3020ca39898751d4200feed776861dcd1ceNate Begeman 10010533b3020ca39898751d4200feed776861dcd1ceNate Begeman // FIXME: evaluate codegen vs. shuffling against constant null vector. 10020533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers. 10032acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *EltTy = VType->getElementType(); 10040533b3020ca39898751d4200feed776861dcd1ceNate Begeman 10050533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers 10060533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { 100748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Value *Idx = Builder.getInt32(CurIdx); 10080533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *Init = llvm::Constant::getNullValue(EltTy); 10090533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 10100533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 10110533b3020ca39898751d4200feed776861dcd1ceNate Begeman return V; 10120533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 10130533b3020ca39898751d4200feed776861dcd1ceNate Begeman 1014a3697c9c155bda93fd2802f37084b620f4738822Anders Carlssonstatic bool ShouldNullCheckClassCastValue(const CastExpr *CE) { 1015a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const Expr *E = CE->getSubExpr(); 101623cba801e11b03929c44f8cf54578305963a3476John McCall 10172de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CE->getCastKind() == CK_UncheckedDerivedToBase) 101823cba801e11b03929c44f8cf54578305963a3476John McCall return false; 1019a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 1020a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (isa<CXXThisExpr>(E)) { 1021a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // We always assume that 'this' is never null. 1022a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 1023a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 1024a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 1025a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) { 1026906082edf2aea1c6de2926f93a8d7121e49d2a54Sebastian Redl // And that glvalue casts are never null. 10275baba9d98364a3525d6afa15a04cdad82fd6dd30John McCall if (ICE->getValueKind() != VK_RValue) 1028a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 1029a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 1030a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 1031a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return true; 1032a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson} 1033a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 1034504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 1035504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// have to handle a more broad range of conversions than explicit casts, as they 1036504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// handle things like function to ptr-to-function decay etc. 1037bc8d40d85f3fa1e34569834916f18fecaa635152John McCallValue *ScalarExprEmitter::VisitCastExpr(CastExpr *CE) { 1038d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Expr *E = CE->getSubExpr(); 1039592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson QualType DestTy = CE->getType(); 10402de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CastKind Kind = CE->getCastKind(); 1041592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson 1042504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson if (!DestTy->isVoidType()) 1043504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson TestAndClearIgnoreResultAssign(); 1044db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10458c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // Since almost all cast kinds apply to scalars, this switch doesn't have 10468c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // a default case, so the compiler will warn on a missing case. The cases 10478c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // are in the same order as in the CastKind enum. 1048504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson switch (Kind) { 1049daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!"); 1050daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 10512de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_LValueBitCast: 10522de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ObjCObjectLValueCast: { 1053e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor Value *V = EmitLValue(E).getAddress(); 1054e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor V = Builder.CreateBitCast(V, 1055e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor ConvertType(CGF.getContext().getPointerType(DestTy))); 1056545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy)); 1057e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor } 1058dc05b11c67331016473fbc7909827b1b89c9616bJohn McCall 10591d9b3b25f7ac0d0195bba6b507a684fe5e7943eeJohn McCall case CK_CPointerToObjCPointerCast: 10601d9b3b25f7ac0d0195bba6b507a684fe5e7943eeJohn McCall case CK_BlockPointerToObjCPointerCast: 10612de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_AnyPointerToBlockPointerCast: 10622de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BitCast: { 1063cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 1064cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson return Builder.CreateBitCast(Src, ConvertType(DestTy)); 1065cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson } 10662de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NoOp: 10672de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UserDefinedConversion: 1068ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Visit(const_cast<Expr*>(E)); 1069db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10702de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerived: { 1071a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const CXXRecordDecl *DerivedClassDecl = 1072a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson DestTy->getCXXRecordDeclForPointerType(); 1073a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 1074a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl, 1075f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 1076a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson ShouldNullCheckClassCastValue(CE)); 1077a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 10782de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UncheckedDerivedToBase: 10792de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBase: { 1080191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson const RecordType *DerivedClassTy = 1081191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson E->getType()->getAs<PointerType>()->getPointeeType()->getAs<RecordType>(); 1082191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson CXXRecordDecl *DerivedClassDecl = 1083191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1084191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 108534a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, 1086f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 108734a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson ShouldNullCheckClassCastValue(CE)); 1088191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson } 1089575b374fdbfc2c2224fd3047ac11ffc4b8db9ae5Anders Carlsson case CK_Dynamic: { 10908c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman Value *V = Visit(const_cast<Expr*>(E)); 10918c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE); 10928c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman return CGF.EmitDynamicCast(V, DCE); 10938c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman } 1094d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 10952de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ArrayToPointerDecay: { 1096ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(E->getType()->isArrayType() && 1097ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Array to pointer decay must have array source type!"); 1098ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1099ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *V = EmitLValue(E).getAddress(); // Bitfields can't be arrays. 1100ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1101ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Note that VLA pointers are always decayed, so we don't need to do 1102ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // anything here. 1103ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman if (!E->getType()->isVariableArrayType()) { 1104ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 1105ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 1106ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman ->getElementType()) && 1107ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Expected pointer to array"); 1108ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman V = Builder.CreateStructGEP(V, 0, "arraydecay"); 1109ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1110ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1111410b12e55395216a02a848a791a38b0f153eba87Chris Lattner // Make sure the array decay ends up being the right type. This matters if 1112410b12e55395216a02a848a791a38b0f153eba87Chris Lattner // the array type was of an incomplete type. 1113cb8095f766f1fe3d664d90ec450093468933f23cChris Lattner return CGF.Builder.CreateBitCast(V, ConvertType(CE->getType())); 1114ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 11152de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FunctionToPointerDecay: 1116ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return EmitLValue(E).getAddress(); 1117ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1118404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall case CK_NullToPointer: 1119404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall if (MustVisitNullValue(E)) 1120404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall (void) Visit(E); 1121404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 1122404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall return llvm::ConstantPointerNull::get( 1123404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall cast<llvm::PointerType>(ConvertType(DestTy))); 1124404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 11252de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NullToMemberPointer: { 1126404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall if (MustVisitNullValue(E)) 1127d608cdb7c044365cf4e8764ade1e11e99c176078John McCall (void) Visit(E); 1128d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 11290bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>(); 11300bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 11310bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 1132191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 11332de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerivedMemberPointer: 11342de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBaseMemberPointer: { 1135d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *Src = Visit(E); 1136d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 1137d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // Note that the AST doesn't distinguish between checked and 1138d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // unchecked member pointer conversions, so we always have to 1139d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // implement checked conversions here. This is inefficient when 1140d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // actual control flow may be required in order to perform the 1141d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // check, which it is for data member pointers (but not member 1142d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // function pointers on Itanium and ARM). 11430bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src); 1144d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 1145f85e193739c953358c865005855253af4f68a497John McCall 114633e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCProduceObject: 1147f85e193739c953358c865005855253af4f68a497John McCall return CGF.EmitARCRetainScalarExpr(E); 114833e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCConsumeObject: 1149f85e193739c953358c865005855253af4f68a497John McCall return CGF.EmitObjCConsumeObject(E->getType(), Visit(E)); 115033e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCReclaimReturnedObject: { 11517e5e5f4cc36fe50f46ad76dca7a266434c94f475John McCall llvm::Value *value = Visit(E); 11527e5e5f4cc36fe50f46ad76dca7a266434c94f475John McCall value = CGF.EmitARCRetainAutoreleasedReturnValue(value); 11537e5e5f4cc36fe50f46ad76dca7a266434c94f475John McCall return CGF.EmitObjCConsumeObject(E->getType(), value); 11547e5e5f4cc36fe50f46ad76dca7a266434c94f475John McCall } 1155348f16fc7c71f0d9b651cb79fd1012843073493fJohn McCall case CK_ARCExtendBlockObject: 1156348f16fc7c71f0d9b651cb79fd1012843073493fJohn McCall return CGF.EmitARCExtendBlockObject(E); 1157f85e193739c953358c865005855253af4f68a497John McCall 11582bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingRealToComplex: 11592bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingComplexCast: 11602bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralRealToComplex: 11612bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralComplexCast: 1162f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToFloatingComplex: 1163f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToIntegralComplex: 11642de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ConstructorConversion: 116561ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall case CK_ToUnion: 116661ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall llvm_unreachable("scalar cast to non-scalar value"); 11678c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman break; 1168f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall 1169f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall case CK_GetObjCProperty: { 1170f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)); 1171da29e091650dc011df5209578d7c049549e5e34bDouglas Gregor assert(E->isGLValue() && E->getObjectKind() == OK_ObjCProperty && 1172f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall "CK_GetObjCProperty for non-lvalue or non-ObjCProperty"); 1173545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall RValue RV = CGF.EmitLoadOfLValue(CGF.EmitLValue(E)); 1174f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall return RV.getScalarVal(); 1175f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall } 11761de4d4e8cb2e9c88809fea8092bc6e835a5473d2John McCall 11770ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall case CK_LValueToRValue: 11780ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)); 1179f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(E->isGLValue() && "lvalue-to-rvalue applied to r-value!"); 11800ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall return Visit(const_cast<Expr*>(E)); 11818c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman 11822de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToPointer: { 11837f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 118489f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 118582debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // First, convert to the correct width so that we control the kind of 118682debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // extension. 11872acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *MiddleTy = CGF.IntPtrTy; 1188575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool InputSigned = E->getType()->isSignedIntegerOrEnumerationType(); 118982debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson llvm::Value* IntResult = 119082debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 119189f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 119282debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy)); 11937f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 11946594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_PointerToIntegral: 11956594942e98e25640f226aba622eb76bcaf0a521cEli Friedman assert(!DestTy->isBooleanType() && "bool should use PointerToBool"); 11966594942e98e25640f226aba622eb76bcaf0a521cEli Friedman return Builder.CreatePtrToInt(Visit(E), ConvertType(DestTy)); 119789f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 11982de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ToVoid: { 11992a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E); 1200ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return 0; 1201ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 12022de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_VectorSplat: { 12032acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *DstTy = ConvertType(DestTy); 1204ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *Elt = Visit(const_cast<Expr*>(E)); 1205ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1206ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Insert the element in element zero of an undef vector 1207ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *UnV = llvm::UndefValue::get(DstTy); 120848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *Idx = Builder.getInt32(0); 1209578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer UnV = Builder.CreateInsertElement(UnV, Elt, Idx); 1210ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1211ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Splat the element across to all elements 12125f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant*, 16> Args; 1213ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 121448431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Constant *Zero = Builder.getInt32(0); 1215ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman for (unsigned i = 0; i < NumElements; i++) 1216daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Args.push_back(Zero); 1217ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1218fb018d153cbf12fd2a4a278cbf7614b9a2e2835eChris Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 1219ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 1220ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Yay; 1221ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1222daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 12232de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralCast: 12242de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToFloating: 12252de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingToIntegral: 12262de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingCast: 1227d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return EmitScalarConversion(Visit(E), E->getType(), DestTy); 1228daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_IntegralToBoolean: 1229daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitIntToBoolConversion(Visit(E)); 1230daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_PointerToBoolean: 1231daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitPointerToBoolConversion(Visit(E)); 1232daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_FloatingToBoolean: 1233daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitFloatToBoolConversion(Visit(E)); 12342de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_MemberPointerToBoolean: { 12350bab0cdab751248ca389a5592bcb70eac5d39260John McCall llvm::Value *MemPtr = Visit(E); 12360bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>(); 12370bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT); 1238e9776247577715ad3a19461769a3488a445a8cbdAnders Carlsson } 1239f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1240f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToReal: 1241f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToReal: 1242b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(E, false, true).first; 1243f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1244f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToBoolean: 1245f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToBoolean: { 1246b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall CodeGenFunction::ComplexPairTy V = CGF.EmitComplexExpr(E); 1247f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1248f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall // TODO: kill this function off, inline appropriate case here 1249f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall return EmitComplexToScalarConversion(V, E->getType(), DestTy); 1250f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall } 1251f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 12520bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 125310b00cfe6422906b223724048b9b2123968d3baaChris Lattner 125461ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall llvm_unreachable("unknown scalar cast"); 125519a1d7c646729eb858b15583e647262a22de3637Chris Lattner return 0; 12567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12583379320c10001d7e1ee5d7e7142c417f797cfe82Chris LattnerValue *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 1259150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::StmtExprEvaluation eval(CGF); 1260150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall return CGF.EmitCompoundStmt(*E->getSubStmt(), !E->getType()->isVoidType()) 1261150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall .getScalarVal(); 12623379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner} 12633379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 1264a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike StumpValue *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 1265a5bcb8fec45d127501cd70fe1654b5a08a8aeb35John McCall LValue LV = CGF.EmitBlockDeclRefLValue(E); 1266545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return CGF.EmitLoadOfLValue(LV).getScalarVal(); 12674e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump} 12683379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 12697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Unary Operators 12717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12738c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *ScalarExprEmitter:: 1274683564a7a93c952f1fbe573b55c542418d29d859Anton YartsevEmitAddConsiderOverflowBehavior(const UnaryOperator *E, 1275683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *InVal, 1276683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *NextVal, bool IsInc) { 1277683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1278683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Undefined: 1279683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return Builder.CreateNSWAdd(InVal, NextVal, IsInc ? "inc" : "dec"); 1280683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev break; 1281683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Defined: 1282683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return Builder.CreateAdd(InVal, NextVal, IsInc ? "inc" : "dec"); 1283683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev break; 1284683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Trapping: 1285683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOpInfo BinOp; 1286683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.LHS = InVal; 1287683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.RHS = NextVal; 1288683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.Ty = E->getType(); 1289683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.Opcode = BO_Add; 1290683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.E = E; 1291683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return EmitOverflowCheckedBinOp(BinOp); 1292683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } 1293b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unknown SignedOverflowBehaviorTy"); 1294683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev} 1295683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 12965936e33bf74dd6bf126ceee0f6169a2593d03a69John McCallllvm::Value * 12975936e33bf74dd6bf126ceee0f6169a2593d03a69John McCallScalarExprEmitter::EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 12985936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall bool isInc, bool isPre) { 12998c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13005936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall QualType type = E->getSubExpr()->getType(); 1301545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall llvm::Value *value = EmitLoadOfLValue(LV); 13025936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *input = value; 13035936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13045936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall int amount = (isInc ? 1 : -1); 13055936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13065936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Special case of integer increment that we have to check first: bool++. 13075936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Due to promotion rules, we get: 13085936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // bool++ -> bool = bool + 1 13095936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // -> bool = (int)bool + 1 13105936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // -> bool = ((int)bool + 1 != 0) 13115936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // An interesting aspect of this is that increment is always true. 13125936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Decrement does not have this property. 13135936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (isInc && type->isBooleanType()) { 13145936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.getTrue(); 13155936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13165936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Most common case by far: integer increment. 13175936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isIntegerType()) { 13185936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13195936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount); 13205936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 1321fa0b409ef81f1f70edfa72857c4e211ff50998d5Eli Friedman // Note that signed integer inc/dec with width less than int can't 1322fa0b409ef81f1f70edfa72857c4e211ff50998d5Eli Friedman // overflow because of promotion rules; we're just eliding a few steps here. 1323575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor if (type->isSignedIntegerOrEnumerationType() && 1324fa0b409ef81f1f70edfa72857c4e211ff50998d5Eli Friedman value->getType()->getPrimitiveSizeInBits() >= 1325913dab2525cc705e5238023a446f5371fa411883John McCall CGF.IntTy->getBitWidth()) 13265936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = EmitAddConsiderOverflowBehavior(E, value, amt, isInc); 13275936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall else 13285936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec"); 13298c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13305936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Next most common: pointer increment. 13315936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (const PointerType *ptr = type->getAs<PointerType>()) { 13325936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall QualType type = ptr->getPointeeType(); 13335936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13345936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // VLA types don't have constant size. 1335913dab2525cc705e5238023a446f5371fa411883John McCall if (const VariableArrayType *vla 1336913dab2525cc705e5238023a446f5371fa411883John McCall = CGF.getContext().getAsVariableArrayType(type)) { 1337913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *numElts = CGF.getVLASize(vla).first; 1338bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (!isInc) numElts = Builder.CreateNSWNeg(numElts, "vla.negsize"); 13392cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 1340bc8d40d85f3fa1e34569834916f18fecaa635152John McCall value = Builder.CreateGEP(value, numElts, "vla.inc"); 13412cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 1342bc8d40d85f3fa1e34569834916f18fecaa635152John McCall value = Builder.CreateInBoundsGEP(value, numElts, "vla.inc"); 13435936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13445936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Arithmetic on function pointers (!) is just +-1. 13455936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isFunctionType()) { 134648431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *amt = Builder.getInt32(amount); 13475936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13485936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = CGF.EmitCastToVoidPtr(value); 13492cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 13502cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateGEP(value, amt, "incdec.funcptr"); 13512cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 13522cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateInBoundsGEP(value, amt, "incdec.funcptr"); 13535936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateBitCast(value, input->getType()); 13545936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13555936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // For everything else, we can just do a simple increment. 13568c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 135748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner llvm::Value *amt = Builder.getInt32(amount); 13582cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 13592cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateGEP(value, amt, "incdec.ptr"); 13602cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 13612cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateInBoundsGEP(value, amt, "incdec.ptr"); 13628c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 13635936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 13645936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Vector increment/decrement. 13655936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isVectorType()) { 13665936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (type->hasIntegerRepresentation()) { 13675936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *amt = llvm::ConstantInt::get(value->getType(), amount); 13685936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 1369d4b9ee3b6ad82843c55909d6499232fce530113eEli Friedman value = Builder.CreateAdd(value, amt, isInc ? "inc" : "dec"); 1370683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } else { 13715936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateFAdd( 13725936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value, 13735936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::ConstantFP::get(value->getType(), amount), 1374683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev isInc ? "inc" : "dec"); 1375683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } 1376683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 13775936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Floating point. 13785936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else if (type->isRealFloatingType()) { 13798c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Add the inc/dec to the real part. 13805936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *amt; 1381aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 1382aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov if (type->isHalfType()) { 1383aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov // Another special case: half FP increment should be done via float 1384aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov value = 1385aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_from_fp16), 1386aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov input); 1387aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov } 1388aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 13895936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (value->getType()->isFloatTy()) 13905936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall amt = llvm::ConstantFP::get(VMContext, 13915936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::APFloat(static_cast<float>(amount))); 13925936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall else if (value->getType()->isDoubleTy()) 13935936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall amt = llvm::ConstantFP::get(VMContext, 13945936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::APFloat(static_cast<double>(amount))); 13958c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else { 13965936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::APFloat F(static_cast<float>(amount)); 13978c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool ignored; 13988c11a65c18ae607b7073e1e451264492d2297726Chris Lattner F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 13998c11a65c18ae607b7073e1e451264492d2297726Chris Lattner &ignored); 14005936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall amt = llvm::ConstantFP::get(VMContext, F); 14018c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 14025936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateFAdd(value, amt, isInc ? "inc" : "dec"); 14035936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 1404aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov if (type->isHalfType()) 1405aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov value = 1406aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov Builder.CreateCall(CGF.CGM.getIntrinsic(llvm::Intrinsic::convert_to_fp16), 1407aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov value); 1408aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 14095936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall // Objective-C pointer types. 14105936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall } else { 14115936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall const ObjCObjectPointerType *OPT = type->castAs<ObjCObjectPointerType>(); 14125936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = CGF.EmitCastToVoidPtr(value); 14135936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 14145936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall CharUnits size = CGF.getContext().getTypeSizeInChars(OPT->getObjectType()); 14155936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall if (!isInc) size = -size; 14165936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::Value *sizeValue = 14175936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall llvm::ConstantInt::get(CGF.SizeTy, size.getQuantity()); 14185936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall 14192cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner if (CGF.getContext().getLangOptions().isSignedOverflowDefined()) 14202cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateGEP(value, sizeValue, "incdec.objptr"); 14212cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner else 14222cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner value = Builder.CreateInBoundsGEP(value, sizeValue, "incdec.objptr"); 14235936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall value = Builder.CreateBitCast(value, input->getType()); 14248c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 1425aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 14268c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Store the updated result through the lvalue. 14278c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (LV.isBitField()) 1428545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughBitfieldLValue(RValue::get(value), LV, &value); 14298c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else 1430545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughLValue(RValue::get(value), LV); 1431aa4a99b4a62615db243f7a5c433169f2fc704420Anton Korobeynikov 14328c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // If this is a postinc, return the value read from memory, otherwise use the 14338c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // updated value. 14345936e33bf74dd6bf126ceee0f6169a2593d03a69John McCall return isPre ? value : input; 14358c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 14368c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 14378c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 14388c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 14397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 14407f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 14419a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Emit unary minus with EmitSub so we handle overflow cases etc. 14429a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOpInfo BinOp; 14434ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.RHS = Visit(E->getSubExpr()); 14444ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner 14454ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner if (BinOp.RHS->getType()->isFPOrFPVectorTy()) 14464ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType()); 14474ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner else 14484ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType()); 14499a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.Ty = E->getType(); 14502de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall BinOp.Opcode = BO_Sub; 14519a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.E = E; 14529a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner return EmitSub(BinOp); 14537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 14567f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 14577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 14587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNot(Op, "neg"); 14597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 14627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Compare operand to zero. 14637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 1464db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 14657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Invert value. 14667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // TODO: Could dynamically modify easy computations here. For example, if 14677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // the operand is an icmp ne, turn into icmp eq. 14687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BoolVal = Builder.CreateNot(BoolVal, "lnot"); 1469db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 14709f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson // ZExt result to the expr type. 14719f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext"); 14727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 14740027d2bb24db629a33a71d04a5fb90a14c15a680Eli FriedmanValue *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) { 14750027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Try folding the offsetof to a constant. 14760027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr::EvalResult EvalResult; 14770027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (E->Evaluate(EvalResult, CGF.getContext())) 147848431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt(EvalResult.Val.getInt()); 14790027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14800027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Loop over the components of the offsetof to compute the value. 14810027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned n = E->getNumComponents(); 14822acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type* ResultType = ConvertType(E->getType()); 14830027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Result = llvm::Constant::getNullValue(ResultType); 14840027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman QualType CurrentType = E->getTypeSourceInfo()->getType(); 14850027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (unsigned i = 0; i != n; ++i) { 14860027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman OffsetOfExpr::OffsetOfNode ON = E->getComponent(i); 148716fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman llvm::Value *Offset = 0; 14880027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman switch (ON.getKind()) { 14890027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Array: { 14900027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index 14910027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex()); 14920027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr); 1493575a1c9dc8dc5b4977194993e289f9eda7295c39Douglas Gregor bool IdxSigned = IdxExpr->getType()->isSignedIntegerOrEnumerationType(); 14940027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv"); 14950027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14960027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type 14970027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = 14980027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getAsArrayType(CurrentType)->getElementType(); 14990027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 15000027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the element size 15010027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType, 15020027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity()); 15030027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 15040027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Multiply out to compute the result 15050027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = Builder.CreateMul(Idx, ElemSize); 15060027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 15070027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15080027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 15090027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Field: { 15100027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldDecl *MemberDecl = ON.getField(); 15110027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 15120027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 15130027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 15140027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index of the field in its parent. 15150027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned i = 0; 15160027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // FIXME: It would be nice if we didn't have to loop here! 15170027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (RecordDecl::field_iterator Field = RD->field_begin(), 15180027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldEnd = RD->field_end(); 15190027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Field != FieldEnd; (void)++Field, ++i) { 15200027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (*Field == MemberDecl) 15210027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 15220027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15230027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman assert(i < RL.getFieldCount() && "offsetof field in wrong type"); 15240027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 15250027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the field 15260027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman int64_t OffsetInt = RL.getFieldOffset(i) / 15270027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 15280027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 15290027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 15300027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 15310027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = MemberDecl->getType(); 15320027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 15330027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 153416fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 15350027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Identifier: 15366d4e44b462fe9e870a40358522379400ccc6e3c2Eli Friedman llvm_unreachable("dependent __builtin_offsetof"); 153716fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 15380027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Base: { 15390027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (ON.getBase()->isVirtual()) { 15400027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.ErrorUnsupported(E, "virtual base in offsetof"); 15410027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman continue; 15420027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15430027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 15440027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 15450027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 15460027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 15470027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 15480027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = ON.getBase()->getType(); 15490027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 15500027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the base. 15510027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const RecordType *BaseRT = CurrentType->getAs<RecordType>(); 15520027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl()); 1553a14f5979572aa25c03d24750ee4724d2031d4edeAnders Carlsson int64_t OffsetInt = RL.getBaseClassOffsetInBits(BaseRD) / 15540027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 15550027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 15560027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 15570027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15580027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15590027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Result = Builder.CreateAdd(Result, Offset); 15600027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 15610027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman return Result; 15628ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor} 15638ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 1564f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne/// VisitUnaryExprOrTypeTraitExpr - Return the size or alignment of the type of 15650518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// argument of the sizeof expression as an integer. 15660518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlValue * 1567f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter CollingbourneScalarExprEmitter::VisitUnaryExprOrTypeTraitExpr( 1568f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne const UnaryExprOrTypeTraitExpr *E) { 15690518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl QualType TypeToSize = E->getTypeOfArgument(); 1570f4e3cfbe8abd124be6341ef5d714819b4fbd9082Peter Collingbourne if (E->getKind() == UETT_SizeOf) { 1571db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (const VariableArrayType *VAT = 1572f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.getContext().getAsVariableArrayType(TypeToSize)) { 1573f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isArgumentType()) { 1574f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // sizeof(type) - make sure to emit the VLA size. 1575bc8d40d85f3fa1e34569834916f18fecaa635152John McCall CGF.EmitVariablyModifiedType(TypeToSize); 15768f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman } else { 15778f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // C99 6.5.3.4p2: If the argument is an expression of type 15788f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // VLA, it is evaluated. 15792a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E->getArgumentExpr()); 1580f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman } 1581db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1582bc8d40d85f3fa1e34569834916f18fecaa635152John McCall QualType eltType; 1583bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *numElts; 1584bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::tie(numElts, eltType) = CGF.getVLASize(VAT); 1585bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1586bc8d40d85f3fa1e34569834916f18fecaa635152John McCall llvm::Value *size = numElts; 1587bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1588bc8d40d85f3fa1e34569834916f18fecaa635152John McCall // Scale the number of non-VLA elements by the non-VLA element size. 1589bc8d40d85f3fa1e34569834916f18fecaa635152John McCall CharUnits eltSize = CGF.getContext().getTypeSizeInChars(eltType); 1590bc8d40d85f3fa1e34569834916f18fecaa635152John McCall if (!eltSize.isOne()) 1591bc8d40d85f3fa1e34569834916f18fecaa635152John McCall size = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), numElts); 1592bc8d40d85f3fa1e34569834916f18fecaa635152John McCall 1593bc8d40d85f3fa1e34569834916f18fecaa635152John McCall return size; 1594b50525ba0e996bc072cdb76152fcfe0bc64bb72aAnders Carlsson } 15955d46315ca3cbbfe0d0f5f65520b618fb05dd4446Anders Carlsson } 1596f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman 1597db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If this isn't sizeof(vla), the result must be constant; use the constant 1598db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // folding logic so we don't have to duplicate it here. 1599f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman Expr::EvalResult Result; 1600f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman E->Evaluate(Result, CGF.getContext()); 160148431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner return Builder.getInt(Result.Val.getInt()); 16027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 16037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 160446f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 160546f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 1606b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (Op->getType()->isAnyComplexType()) { 1607b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If it's an l-value, load through the appropriate subobject l-value. 1608b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Note that we have to ask E because Op might be an l-value that 1609b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // this won't work for, e.g. an Obj-C property. 16107eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (E->isGLValue()) 1611545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return CGF.EmitLoadOfLValue(CGF.EmitLValue(E)).getScalarVal(); 1612b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1613b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Otherwise, calculate and project. 1614b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(Op, false, true).first; 1615b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall } 1616b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 161746f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return Visit(Op); 161846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 1619b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 162046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 162146f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 1622b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (Op->getType()->isAnyComplexType()) { 1623b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If it's an l-value, load through the appropriate subobject l-value. 1624b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Note that we have to ask E because Op might be an l-value that 1625b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // this won't work for, e.g. an Obj-C property. 16267eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (Op->isGLValue()) 1627545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return CGF.EmitLoadOfLValue(CGF.EmitLValue(E)).getScalarVal(); 1628b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1629b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Otherwise, calculate and project. 1630b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(Op, true, false).second; 1631b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall } 1632db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 16337f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __imag on a scalar returns zero. Emit the subexpr to ensure side 16347f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // effects are evaluated, but not the actual value. 1635b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall CGF.EmitScalarExpr(Op, true); 1636c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson return llvm::Constant::getNullValue(ConvertType(E->getType())); 163746f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 163846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 16397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 16407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Binary Operators 16417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 16427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerBinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 16447f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 16457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BinOpInfo Result; 16467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.LHS = Visit(E->getLHS()); 16477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.RHS = Visit(E->getRHS()); 16481f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Result.Ty = E->getType(); 16499a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner Result.Opcode = E->getOpcode(); 16507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.E = E; 16517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Result; 16527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 16537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16546a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue ScalarExprEmitter::EmitCompoundAssignLValue( 16556a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E, 16566a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), 1657d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result) { 165854d76db0aa7107597cac0b80d8e138a37e6d1de9Benjamin Kramer QualType LHSTy = E->getLHS()->getType(); 16591f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo OpInfo; 16606a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1661ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman if (E->getComputationResultType()->isAnyComplexType()) { 1662db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // This needs to go through the complex expression emitter, but it's a tad 1663db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // complicated to do that... I'm leaving it out for now. (Note that we do 1664db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // actually need the imaginary part of the RHS for multiplication and 1665db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // division.) 1666ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman CGF.ErrorUnsupported(E, "complex compound assignment"); 1667d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = llvm::UndefValue::get(CGF.ConvertType(E->getType())); 16686a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LValue(); 16691f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 16706a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1671cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // Emit the RHS first. __block variables need to have the rhs evaluated 1672cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // first, plus this should improve codegen a little. 1673cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.RHS = Visit(E->getRHS()); 1674cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.Ty = E->getComputationResultType(); 16759a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OpInfo.Opcode = E->getOpcode(); 1676cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.E = E; 1677ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // Load/convert the LHS. 1678b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHSLV = EmitCheckedLValue(E->getLHS()); 1679545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall OpInfo.LHS = EmitLoadOfLValue(LHSLV); 1680ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 1681ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman E->getComputationLHSType()); 16826a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 16831f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Expand the binary operator. 1684d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = (this->*Func)(OpInfo); 16856a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 16868c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Convert the result back to the LHS type. 1687ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 16886a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1689db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Store the result value into the LHS lvalue. Bit-fields are handled 1690db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // specially because the result is altered by the store, i.e., [C99 6.5.16p1] 1691db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // 'An assignment expression has the value of the left operand after the 1692db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // assignment...'. 1693d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHSLV.isBitField()) 1694545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, &Result); 1695d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 1696545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV); 1697d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 16986a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LHSLV; 16996a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 17006a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 17016a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorValue *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 17026a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 17036a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor bool Ignore = TestAndClearIgnoreResultAssign(); 1704d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *RHS; 1705d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar LValue LHS = EmitCompoundAssignLValue(E, Func, RHS); 1706d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1707d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 17087f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 17097f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 1710d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1711b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 1712b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!CGF.getContext().getLangOptions().CPlusPlus) 1713b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return RHS; 1714b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1715d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 1716119a1c6c4029d30cae7b31a2826aa0ff70d01668John McCall if (LHS.isPropertyRef()) 1717d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1718d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1719d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 1720d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 1721d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1722d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1723d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 1724545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return EmitLoadOfLValue(LHS); 17251f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner} 17261f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 17278023030f76d334355b73d9c675d3870858aaf4fdChris Lattnervoid ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck( 17288023030f76d334355b73d9c675d3870858aaf4fdChris Lattner const BinOpInfo &Ops, 17298023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero, bool isDiv) { 173014ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::Function::iterator insertPt = Builder.GetInsertBlock(); 17318023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *contBB = 173214ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling CGF.createBasicBlock(isDiv ? "div.cont" : "rem.cont", CGF.CurFn, 173314ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::next(insertPt)); 173414ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 17358023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 17362acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType()); 17378023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 17388023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->hasSignedIntegerRepresentation()) { 17398023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *IntMin = 174048431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Builder.getInt(llvm::APInt::getSignedMinValue(Ty->getBitWidth())); 17418023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL); 17428023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 17438023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond1 = Builder.CreateICmpEQ(Ops.RHS, Zero); 17448023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *LHSCmp = Builder.CreateICmpEQ(Ops.LHS, IntMin); 17458023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *RHSCmp = Builder.CreateICmpEQ(Ops.RHS, NegOne); 17468023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond2 = Builder.CreateAnd(LHSCmp, RHSCmp, "and"); 17478023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCondBr(Builder.CreateOr(Cond1, Cond2, "or"), 17488023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 17498023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } else { 17508023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateICmpEQ(Ops.RHS, Zero), 17518023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 17528023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 17538023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 17548023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(contBB); 17558023030f76d334355b73d9c675d3870858aaf4fdChris Lattner} 17561f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 17577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 17588023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 17598023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 17608023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 17618023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 17628023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true); 17638023030f76d334355b73d9c675d3870858aaf4fdChris Lattner else if (Ops.Ty->isRealFloatingType()) { 176414ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::Function::iterator insertPt = Builder.GetInsertBlock(); 176514ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::BasicBlock *DivCont = CGF.createBasicBlock("div.cont", CGF.CurFn, 176614ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::next(insertPt)); 17678023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", 17688023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.CurFn); 17698023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero), 17708023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, DivCont); 17718023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 17728023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(DivCont); 17738023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 17748023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 1775f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 17767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 1777f60946222721d9ba3c059563935c17b84703187aDouglas Gregor else if (Ops.Ty->hasUnsignedIntegerRepresentation()) 17787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 17797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 17807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 17817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 17847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Rem in C can't be a floating point type: C99 6.5.5p2. 17858023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 17868023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 17878023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 17888023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 17898023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false); 17908023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 17918023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 179252d6874271829c4f5bb70121fb678c27780ce65aEli Friedman if (Ops.Ty->hasUnsignedIntegerRepresentation()) 17937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 17947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 17957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 17967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17982add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike StumpValue *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 17992add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned IID; 18002add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned OpID = 0; 18015d8b2cf9fd704f6ca5e33525803a65421c0b440eMike Stump 18029a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner switch (Ops.Opcode) { 18032de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 18042de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_AddAssign: 1805035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 1; 1806035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::sadd_with_overflow; 1807035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 18082de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 18092de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_SubAssign: 1810035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 2; 1811035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::ssub_with_overflow; 1812035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 18132de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 18142de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_MulAssign: 1815035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 3; 1816035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::smul_with_overflow; 1817035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1818035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump default: 1819b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Unsupported operation for overflow detection"); 1820ab4eff620a9ce0ea62cdf29529a66c2c98d116f5Daniel Dunbar IID = 0; 1821035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump } 1822035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID <<= 1; 1823035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID |= 1; 1824035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump 18259cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattner llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 18262add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 18278dd55a3c3b28d195717c87bbc60e765951d408feBenjamin Kramer llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, opTy); 18282add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 18292add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 18302add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 18312add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 18322add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 18332add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Branch in case of overflow. 18347f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::BasicBlock *initialBB = Builder.GetInsertBlock(); 183514ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::Function::iterator insertPt = initialBB; 183614ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn, 183714ef3191a75b8bcdab391e6ffa6367b731c2ce67Bill Wendling llvm::next(insertPt)); 183893a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 18392add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 18402add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateCondBr(overflow, overflowBB, continueBB); 18412add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 184293a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner // Handle overflow with llvm.trap. 18437f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall const std::string *handlerName = 18447f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall &CGF.getContext().getLangOptions().OverflowHandler; 18457f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall if (handlerName->empty()) { 18467f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall EmitOverflowBB(overflowBB); 18477f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(continueBB); 18487f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return result; 18497f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall } 18507f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18517f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // If an overflow handler is set, then we want to call it and then use its 18527f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // result, if it returns. 18537f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(overflowBB); 18547f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18557f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Get the overflow handler. 18569cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattner llvm::Type *Int8Ty = llvm::Type::getInt8Ty(VMContext); 18579cbe4f0ba01ec304e1e3d071c071f7bca33631c0Chris Lattner llvm::Type *argTypes[] = { CGF.Int64Ty, CGF.Int64Ty, Int8Ty, Int8Ty }; 18587f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType *handlerTy = 18597f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType::get(CGF.Int64Ty, argTypes, true); 18607f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName); 18617f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18627f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Sign extend the args to 64-bit, so that we can use the same handler for 18637f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // all types of overflow. 18647f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty); 18657f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty); 18667f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18677f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Call the handler with the two arguments, the operation, and the size of 18687f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // the result. 18697f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handlerResult = Builder.CreateCall4(handler, lhs, rhs, 18707f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(OpID), 18717f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())); 18727f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18737f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Truncate the result back to the desired size. 18747f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall handlerResult = Builder.CreateTrunc(handlerResult, opTy); 18757f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.CreateBr(continueBB); 18767f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18772add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(continueBB); 1878bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *phi = Builder.CreatePHI(opTy, 2); 18797f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(result, initialBB); 18807f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(handlerResult, overflowBB); 18817f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 18827f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return phi; 18832add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump} 18847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1885913dab2525cc705e5238023a446f5371fa411883John McCall/// Emit pointer + index arithmetic. 1886913dab2525cc705e5238023a446f5371fa411883John McCallstatic Value *emitPointerArithmetic(CodeGenFunction &CGF, 1887913dab2525cc705e5238023a446f5371fa411883John McCall const BinOpInfo &op, 1888913dab2525cc705e5238023a446f5371fa411883John McCall bool isSubtraction) { 1889913dab2525cc705e5238023a446f5371fa411883John McCall // Must have binary (not unary) expr here. Unary pointer 1890913dab2525cc705e5238023a446f5371fa411883John McCall // increment/decrement doesn't use this path. 1891913dab2525cc705e5238023a446f5371fa411883John McCall const BinaryOperator *expr = cast<BinaryOperator>(op.E); 18929a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 1893913dab2525cc705e5238023a446f5371fa411883John McCall Value *pointer = op.LHS; 1894913dab2525cc705e5238023a446f5371fa411883John McCall Expr *pointerOperand = expr->getLHS(); 1895913dab2525cc705e5238023a446f5371fa411883John McCall Value *index = op.RHS; 1896913dab2525cc705e5238023a446f5371fa411883John McCall Expr *indexOperand = expr->getRHS(); 1897913dab2525cc705e5238023a446f5371fa411883John McCall 1898913dab2525cc705e5238023a446f5371fa411883John McCall // In a subtraction, the LHS is always the pointer. 1899913dab2525cc705e5238023a446f5371fa411883John McCall if (!isSubtraction && !pointer->getType()->isPointerTy()) { 1900913dab2525cc705e5238023a446f5371fa411883John McCall std::swap(pointer, index); 1901913dab2525cc705e5238023a446f5371fa411883John McCall std::swap(pointerOperand, indexOperand); 1902913dab2525cc705e5238023a446f5371fa411883John McCall } 1903913dab2525cc705e5238023a446f5371fa411883John McCall 1904913dab2525cc705e5238023a446f5371fa411883John McCall unsigned width = cast<llvm::IntegerType>(index->getType())->getBitWidth(); 1905913dab2525cc705e5238023a446f5371fa411883John McCall if (width != CGF.PointerWidthInBits) { 1906913dab2525cc705e5238023a446f5371fa411883John McCall // Zero-extend or sign-extend the pointer value according to 1907913dab2525cc705e5238023a446f5371fa411883John McCall // whether the index is signed or not. 1908913dab2525cc705e5238023a446f5371fa411883John McCall bool isSigned = indexOperand->getType()->isSignedIntegerOrEnumerationType(); 1909913dab2525cc705e5238023a446f5371fa411883John McCall index = CGF.Builder.CreateIntCast(index, CGF.PtrDiffTy, isSigned, 1910913dab2525cc705e5238023a446f5371fa411883John McCall "idx.ext"); 1911913dab2525cc705e5238023a446f5371fa411883John McCall } 1912913dab2525cc705e5238023a446f5371fa411883John McCall 1913913dab2525cc705e5238023a446f5371fa411883John McCall // If this is subtraction, negate the index. 1914913dab2525cc705e5238023a446f5371fa411883John McCall if (isSubtraction) 1915913dab2525cc705e5238023a446f5371fa411883John McCall index = CGF.Builder.CreateNeg(index, "idx.neg"); 1916913dab2525cc705e5238023a446f5371fa411883John McCall 1917913dab2525cc705e5238023a446f5371fa411883John McCall const PointerType *pointerType 1918913dab2525cc705e5238023a446f5371fa411883John McCall = pointerOperand->getType()->getAs<PointerType>(); 1919913dab2525cc705e5238023a446f5371fa411883John McCall if (!pointerType) { 1920913dab2525cc705e5238023a446f5371fa411883John McCall QualType objectType = pointerOperand->getType() 1921913dab2525cc705e5238023a446f5371fa411883John McCall ->castAs<ObjCObjectPointerType>() 1922913dab2525cc705e5238023a446f5371fa411883John McCall ->getPointeeType(); 1923913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *objectSize 1924913dab2525cc705e5238023a446f5371fa411883John McCall = CGF.CGM.getSize(CGF.getContext().getTypeSizeInChars(objectType)); 1925913dab2525cc705e5238023a446f5371fa411883John McCall 1926913dab2525cc705e5238023a446f5371fa411883John McCall index = CGF.Builder.CreateMul(index, objectSize); 1927913dab2525cc705e5238023a446f5371fa411883John McCall 1928913dab2525cc705e5238023a446f5371fa411883John McCall Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy); 1929913dab2525cc705e5238023a446f5371fa411883John McCall result = CGF.Builder.CreateGEP(result, index, "add.ptr"); 1930913dab2525cc705e5238023a446f5371fa411883John McCall return CGF.Builder.CreateBitCast(result, pointer->getType()); 1931913dab2525cc705e5238023a446f5371fa411883John McCall } 1932913dab2525cc705e5238023a446f5371fa411883John McCall 1933913dab2525cc705e5238023a446f5371fa411883John McCall QualType elementType = pointerType->getPointeeType(); 1934913dab2525cc705e5238023a446f5371fa411883John McCall if (const VariableArrayType *vla 1935913dab2525cc705e5238023a446f5371fa411883John McCall = CGF.getContext().getAsVariableArrayType(elementType)) { 1936913dab2525cc705e5238023a446f5371fa411883John McCall // The element count here is the total number of non-VLA elements. 1937913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *numElements = CGF.getVLASize(vla).first; 1938913dab2525cc705e5238023a446f5371fa411883John McCall 1939913dab2525cc705e5238023a446f5371fa411883John McCall // Effectively, the multiply by the VLA size is part of the GEP. 1940913dab2525cc705e5238023a446f5371fa411883John McCall // GEP indexes are signed, and scaling an index isn't permitted to 1941913dab2525cc705e5238023a446f5371fa411883John McCall // signed-overflow, so we use the same semantics for our explicit 1942913dab2525cc705e5238023a446f5371fa411883John McCall // multiply. We suppress this if overflow is not undefined behavior. 1943913dab2525cc705e5238023a446f5371fa411883John McCall if (CGF.getLangOptions().isSignedOverflowDefined()) { 1944913dab2525cc705e5238023a446f5371fa411883John McCall index = CGF.Builder.CreateMul(index, numElements, "vla.index"); 1945913dab2525cc705e5238023a446f5371fa411883John McCall pointer = CGF.Builder.CreateGEP(pointer, index, "add.ptr"); 1946913dab2525cc705e5238023a446f5371fa411883John McCall } else { 1947913dab2525cc705e5238023a446f5371fa411883John McCall index = CGF.Builder.CreateNSWMul(index, numElements, "vla.index"); 1948913dab2525cc705e5238023a446f5371fa411883John McCall pointer = CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr"); 1949913dab2525cc705e5238023a446f5371fa411883John McCall } 1950913dab2525cc705e5238023a446f5371fa411883John McCall return pointer; 1951db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 19522a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1953db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Explicitly handle GNU void* and function pointer arithmetic extensions. The 1954db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // GNU void* casts amount to no-ops since our void* type is i8*, but this is 1955db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // future proof. 1956913dab2525cc705e5238023a446f5371fa411883John McCall if (elementType->isVoidType() || elementType->isFunctionType()) { 1957913dab2525cc705e5238023a446f5371fa411883John McCall Value *result = CGF.Builder.CreateBitCast(pointer, CGF.VoidPtrTy); 1958913dab2525cc705e5238023a446f5371fa411883John McCall result = CGF.Builder.CreateGEP(result, index, "add.ptr"); 1959913dab2525cc705e5238023a446f5371fa411883John McCall return CGF.Builder.CreateBitCast(result, pointer->getType()); 1960db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1961db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1962913dab2525cc705e5238023a446f5371fa411883John McCall if (CGF.getLangOptions().isSignedOverflowDefined()) 1963913dab2525cc705e5238023a446f5371fa411883John McCall return CGF.Builder.CreateGEP(pointer, index, "add.ptr"); 1964913dab2525cc705e5238023a446f5371fa411883John McCall 1965913dab2525cc705e5238023a446f5371fa411883John McCall return CGF.Builder.CreateInBoundsGEP(pointer, index, "add.ptr"); 19667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1968913dab2525cc705e5238023a446f5371fa411883John McCallValue *ScalarExprEmitter::EmitAdd(const BinOpInfo &op) { 1969913dab2525cc705e5238023a446f5371fa411883John McCall if (op.LHS->getType()->isPointerTy() || 1970913dab2525cc705e5238023a446f5371fa411883John McCall op.RHS->getType()->isPointerTy()) 1971913dab2525cc705e5238023a446f5371fa411883John McCall return emitPointerArithmetic(CGF, op, /*subtraction*/ false); 1972913dab2525cc705e5238023a446f5371fa411883John McCall 1973913dab2525cc705e5238023a446f5371fa411883John McCall if (op.Ty->isSignedIntegerOrEnumerationType()) { 1974913dab2525cc705e5238023a446f5371fa411883John McCall switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1975913dab2525cc705e5238023a446f5371fa411883John McCall case LangOptions::SOB_Undefined: 1976913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateNSWAdd(op.LHS, op.RHS, "add"); 1977913dab2525cc705e5238023a446f5371fa411883John McCall case LangOptions::SOB_Defined: 1978913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateAdd(op.LHS, op.RHS, "add"); 1979913dab2525cc705e5238023a446f5371fa411883John McCall case LangOptions::SOB_Trapping: 1980913dab2525cc705e5238023a446f5371fa411883John McCall return EmitOverflowCheckedBinOp(op); 1981913dab2525cc705e5238023a446f5371fa411883John McCall } 1982913dab2525cc705e5238023a446f5371fa411883John McCall } 1983913dab2525cc705e5238023a446f5371fa411883John McCall 1984913dab2525cc705e5238023a446f5371fa411883John McCall if (op.LHS->getType()->isFPOrFPVectorTy()) 1985913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateFAdd(op.LHS, op.RHS, "add"); 1986913dab2525cc705e5238023a446f5371fa411883John McCall 1987913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateAdd(op.LHS, op.RHS, "add"); 1988913dab2525cc705e5238023a446f5371fa411883John McCall} 1989913dab2525cc705e5238023a446f5371fa411883John McCall 1990913dab2525cc705e5238023a446f5371fa411883John McCallValue *ScalarExprEmitter::EmitSub(const BinOpInfo &op) { 1991913dab2525cc705e5238023a446f5371fa411883John McCall // The LHS is always a pointer if either side is. 1992913dab2525cc705e5238023a446f5371fa411883John McCall if (!op.LHS->getType()->isPointerTy()) { 1993913dab2525cc705e5238023a446f5371fa411883John McCall if (op.Ty->isSignedIntegerOrEnumerationType()) { 1994a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1995a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1996913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateNSWSub(op.LHS, op.RHS, "sub"); 1997a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1998913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateSub(op.LHS, op.RHS, "sub"); 1999a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 2000913dab2525cc705e5238023a446f5371fa411883John McCall return EmitOverflowCheckedBinOp(op); 2001a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 2002a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 2003a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 2004913dab2525cc705e5238023a446f5371fa411883John McCall if (op.LHS->getType()->isFPOrFPVectorTy()) 2005913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateFSub(op.LHS, op.RHS, "sub"); 20062eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner 2007913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateSub(op.LHS, op.RHS, "sub"); 20082add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 20091f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 2010913dab2525cc705e5238023a446f5371fa411883John McCall // If the RHS is not a pointer, then we have normal pointer 2011913dab2525cc705e5238023a446f5371fa411883John McCall // arithmetic. 2012913dab2525cc705e5238023a446f5371fa411883John McCall if (!op.RHS->getType()->isPointerTy()) 2013913dab2525cc705e5238023a446f5371fa411883John McCall return emitPointerArithmetic(CGF, op, /*subtraction*/ true); 20142a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 2015913dab2525cc705e5238023a446f5371fa411883John McCall // Otherwise, this is a pointer subtraction. 2016db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2017913dab2525cc705e5238023a446f5371fa411883John McCall // Do the raw subtraction part. 2018913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *LHS 2019913dab2525cc705e5238023a446f5371fa411883John McCall = Builder.CreatePtrToInt(op.LHS, CGF.PtrDiffTy, "sub.ptr.lhs.cast"); 2020913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *RHS 2021913dab2525cc705e5238023a446f5371fa411883John McCall = Builder.CreatePtrToInt(op.RHS, CGF.PtrDiffTy, "sub.ptr.rhs.cast"); 2022913dab2525cc705e5238023a446f5371fa411883John McCall Value *diffInChars = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 2023db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2024913dab2525cc705e5238023a446f5371fa411883John McCall // Okay, figure out the element size. 2025913dab2525cc705e5238023a446f5371fa411883John McCall const BinaryOperator *expr = cast<BinaryOperator>(op.E); 2026913dab2525cc705e5238023a446f5371fa411883John McCall QualType elementType = expr->getLHS()->getType()->getPointeeType(); 2027df1109434abd465a4db2e6f69ec2688866660367Dan Gohman 2028913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *divisor = 0; 2029913dab2525cc705e5238023a446f5371fa411883John McCall 2030913dab2525cc705e5238023a446f5371fa411883John McCall // For a variable-length array, this is going to be non-constant. 2031913dab2525cc705e5238023a446f5371fa411883John McCall if (const VariableArrayType *vla 2032913dab2525cc705e5238023a446f5371fa411883John McCall = CGF.getContext().getAsVariableArrayType(elementType)) { 2033913dab2525cc705e5238023a446f5371fa411883John McCall llvm::Value *numElements; 2034913dab2525cc705e5238023a446f5371fa411883John McCall llvm::tie(numElements, elementType) = CGF.getVLASize(vla); 20352cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner 2036913dab2525cc705e5238023a446f5371fa411883John McCall divisor = numElements; 20372cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner 2038913dab2525cc705e5238023a446f5371fa411883John McCall // Scale the number of non-VLA elements by the non-VLA element size. 2039913dab2525cc705e5238023a446f5371fa411883John McCall CharUnits eltSize = CGF.getContext().getTypeSizeInChars(elementType); 2040913dab2525cc705e5238023a446f5371fa411883John McCall if (!eltSize.isOne()) 2041913dab2525cc705e5238023a446f5371fa411883John McCall divisor = CGF.Builder.CreateNUWMul(CGF.CGM.getSize(eltSize), divisor); 20422cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner 2043913dab2525cc705e5238023a446f5371fa411883John McCall // For everything elese, we can just compute it, safe in the 2044913dab2525cc705e5238023a446f5371fa411883John McCall // assumption that Sema won't let anything through that we can't 2045913dab2525cc705e5238023a446f5371fa411883John McCall // safely compute the size of. 2046913dab2525cc705e5238023a446f5371fa411883John McCall } else { 2047913dab2525cc705e5238023a446f5371fa411883John McCall CharUnits elementSize; 2048913dab2525cc705e5238023a446f5371fa411883John McCall // Handle GCC extension for pointer arithmetic on void* and 2049913dab2525cc705e5238023a446f5371fa411883John McCall // function pointer types. 2050913dab2525cc705e5238023a446f5371fa411883John McCall if (elementType->isVoidType() || elementType->isFunctionType()) 2051913dab2525cc705e5238023a446f5371fa411883John McCall elementSize = CharUnits::One(); 2052913dab2525cc705e5238023a446f5371fa411883John McCall else 2053913dab2525cc705e5238023a446f5371fa411883John McCall elementSize = CGF.getContext().getTypeSizeInChars(elementType); 2054913dab2525cc705e5238023a446f5371fa411883John McCall 2055913dab2525cc705e5238023a446f5371fa411883John McCall // Don't even emit the divide for element size of 1. 2056913dab2525cc705e5238023a446f5371fa411883John McCall if (elementSize.isOne()) 2057913dab2525cc705e5238023a446f5371fa411883John McCall return diffInChars; 2058913dab2525cc705e5238023a446f5371fa411883John McCall 2059913dab2525cc705e5238023a446f5371fa411883John McCall divisor = CGF.CGM.getSize(elementSize); 2060913dab2525cc705e5238023a446f5371fa411883John McCall } 2061913dab2525cc705e5238023a446f5371fa411883John McCall 20622cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 20632cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // pointer difference in C is only defined in the case where both operands 20642cb4222338669a3e70b546ef264fbd5d3f96aef5Chris Lattner // are pointing to elements of an array. 2065913dab2525cc705e5238023a446f5371fa411883John McCall return Builder.CreateExactSDiv(diffInChars, divisor, "sub.ptr.div"); 20667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 20687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 20697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 20707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 20717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 20727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 20737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 2074db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2075be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 2076be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 2077be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 2078be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 2079be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 2080be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 208115037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 2082be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 2083be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 2084be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 20857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateShl(Ops.LHS, RHS, "shl"); 20867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 20887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 20897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 20907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 20917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 20927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 20937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 2094db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2095be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 2096be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 2097be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 2098be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 2099be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 2100be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 210115037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 2102be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 2103be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 2104be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 2105f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasUnsignedIntegerRepresentation()) 21067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 21077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 21087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 21097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2110aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsevenum IntrinsicType { VCMPEQ, VCMPGT }; 2111aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev// return corresponding comparison intrinsic for given vector type 2112aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsevstatic llvm::Intrinsic::ID GetIntrinsic(IntrinsicType IT, 2113aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev BuiltinType::Kind ElemKind) { 2114aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev switch (ElemKind) { 2115b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("unexpected element type"); 2116aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Char_U: 2117aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UChar: 2118aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 2119aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtub_p; 2120aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2121aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Char_S: 2122aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::SChar: 2123aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 2124aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsb_p; 2125aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2126aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UShort: 2127aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 2128aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtuh_p; 2129aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2130aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Short: 2131aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 2132aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsh_p; 2133aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2134aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UInt: 2135aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::ULong: 2136aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 2137aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtuw_p; 2138aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2139aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Int: 2140aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Long: 2141aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 2142aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsw_p; 2143aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2144aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Float: 2145aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p : 2146aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtfp_p; 2147aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2148aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2149aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return llvm::Intrinsic::not_intrinsic; 2150aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev} 2151aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 21527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 21537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc) { 21547f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 21554f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *Result; 21567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner QualType LHSTy = E->getLHS()->getType(); 21570bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) { 21582de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_EQ || 21592de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall E->getOpcode() == BO_NE); 2160d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *LHS = CGF.EmitScalarExpr(E->getLHS()); 2161d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *RHS = CGF.EmitScalarExpr(E->getRHS()); 21620bab0cdab751248ca389a5592bcb70eac5d39260John McCall Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison( 21632de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE); 2164b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else if (!LHSTy->isAnyComplexType()) { 21657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS = Visit(E->getLHS()); 21667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 2167db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2168aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // If AltiVec, the comparison results in a numeric type, so we use 2169aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // intrinsics comparing vectors and giving 0 or 1 as a result 21706305f721247f13707d9858b17d5696c1e3428a78Anton Yartsev if (LHSTy->isVectorType() && !E->getType()->isVectorType()) { 2171aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // constants for mapping CR6 register bits to predicate result 2172aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6; 2173aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2174aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ID ID = llvm::Intrinsic::not_intrinsic; 2175aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2176aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // in several cases vector arguments order will be reversed 2177aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Value *FirstVecArg = LHS, 2178aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev *SecondVecArg = RHS; 2179aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2180aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev QualType ElTy = LHSTy->getAs<VectorType>()->getElementType(); 2181f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const BuiltinType *BTy = ElTy->getAs<BuiltinType>(); 2182aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev BuiltinType::Kind ElementKind = BTy->getKind(); 2183aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2184aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev switch(E->getOpcode()) { 2185b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie default: llvm_unreachable("is not a comparison operation"); 2186aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_EQ: 2187aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2188aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPEQ, ElementKind); 2189aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2190aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_NE: 2191aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2192aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPEQ, ElementKind); 2193aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2194aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_LT: 2195aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2196aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2197aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2198aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2199aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_GT: 2200aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2201aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2202aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2203aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_LE: 2204aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (ElementKind == BuiltinType::Float) { 2205aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2206aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 2207aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2208aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2209aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev else { 2210aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2211aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2212aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2213aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2214aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_GE: 2215aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (ElementKind == BuiltinType::Float) { 2216aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2217aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 2218aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2219aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev else { 2220aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2221aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2222aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2223aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2224aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2225aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2226aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 222748431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Value *CR6Param = Builder.getInt32(CR6); 2228aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Function *F = CGF.CGM.getIntrinsic(ID); 2229aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Result = Builder.CreateCall3(F, CR6Param, FirstVecArg, SecondVecArg, ""); 2230aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 2231aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2232aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2233f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (LHS->getType()->isFPOrFPVectorTy()) { 22347a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 22357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 2236f60946222721d9ba3c059563935c17b84703187aDouglas Gregor } else if (LHSTy->hasSignedIntegerRepresentation()) { 2237ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 22387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 22397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 2240ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman // Unsigned integers and pointers. 2241ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 22427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 22437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 22449c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner 22459c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // If this is a vector comparison, sign extend the result to the appropriate 22469c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // vector integer type and return it (don't convert to bool). 22479c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner if (LHSTy->isVectorType()) 22489c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 2249db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 22517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex Comparison: can only be an equality comparison. 22527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 22537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 2254db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2255183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType CETy = LHSTy->getAs<ComplexType>()->getElementType(); 2256db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22574f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *ResultR, *ResultI; 22587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (CETy->isRealFloatingType()) { 22597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 22607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 22617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 22627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 22637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 22647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex comparisons can only be equality comparisons. As such, signed 22657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // and unsigned opcodes are the same. 22667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 22677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 22687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 22697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 22707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2271db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22722de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (E->getOpcode() == BO_EQ) { 22737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 22747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 22752de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_NE && 22767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Complex comparison other than == or != ?"); 22777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 22787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 22797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 228032f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes 228132f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 22827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 22837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 22847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 22857f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool Ignore = TestAndClearIgnoreResultAssign(); 22867f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 2287f85e193739c953358c865005855253af4f68a497John McCall Value *RHS; 2288f85e193739c953358c865005855253af4f68a497John McCall LValue LHS; 2289f85e193739c953358c865005855253af4f68a497John McCall 2290f85e193739c953358c865005855253af4f68a497John McCall switch (E->getLHS()->getType().getObjCLifetime()) { 2291f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Strong: 2292f85e193739c953358c865005855253af4f68a497John McCall llvm::tie(LHS, RHS) = CGF.EmitARCStoreStrong(E, Ignore); 2293f85e193739c953358c865005855253af4f68a497John McCall break; 2294f85e193739c953358c865005855253af4f68a497John McCall 2295f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Autoreleasing: 2296f85e193739c953358c865005855253af4f68a497John McCall llvm::tie(LHS,RHS) = CGF.EmitARCStoreAutoreleasing(E); 2297f85e193739c953358c865005855253af4f68a497John McCall break; 2298f85e193739c953358c865005855253af4f68a497John McCall 2299f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_Weak: 2300f85e193739c953358c865005855253af4f68a497John McCall RHS = Visit(E->getRHS()); 2301f85e193739c953358c865005855253af4f68a497John McCall LHS = EmitCheckedLValue(E->getLHS()); 2302f85e193739c953358c865005855253af4f68a497John McCall RHS = CGF.EmitARCStoreWeak(LHS.getAddress(), RHS, Ignore); 2303f85e193739c953358c865005855253af4f68a497John McCall break; 2304f85e193739c953358c865005855253af4f68a497John McCall 2305f85e193739c953358c865005855253af4f68a497John McCall // No reason to do any of these differently. 2306f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_None: 2307f85e193739c953358c865005855253af4f68a497John McCall case Qualifiers::OCL_ExplicitNone: 2308f85e193739c953358c865005855253af4f68a497John McCall // __block variables need to have the rhs evaluated first, plus 2309f85e193739c953358c865005855253af4f68a497John McCall // this should improve codegen just a little. 2310f85e193739c953358c865005855253af4f68a497John McCall RHS = Visit(E->getRHS()); 2311f85e193739c953358c865005855253af4f68a497John McCall LHS = EmitCheckedLValue(E->getLHS()); 2312f85e193739c953358c865005855253af4f68a497John McCall 2313f85e193739c953358c865005855253af4f68a497John McCall // Store the value into the LHS. Bit-fields are handled specially 2314f85e193739c953358c865005855253af4f68a497John McCall // because the result is altered by the store, i.e., [C99 6.5.16p1] 2315f85e193739c953358c865005855253af4f68a497John McCall // 'An assignment expression has the value of the left operand after 2316f85e193739c953358c865005855253af4f68a497John McCall // the assignment...'. 2317f85e193739c953358c865005855253af4f68a497John McCall if (LHS.isBitField()) 2318545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, &RHS); 2319f85e193739c953358c865005855253af4f68a497John McCall else 2320545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS); 2321f85e193739c953358c865005855253af4f68a497John McCall } 2322d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2323d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 23247f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 23257f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 2326d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2327b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 2328b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!CGF.getContext().getLangOptions().CPlusPlus) 2329b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return RHS; 2330b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 2331d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 2332119a1c6c4029d30cae7b31a2826aa0ff70d01668John McCall if (LHS.isPropertyRef()) 2333d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2334d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2335d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 2336d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 2337d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2338d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2339d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 2340545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall return EmitLoadOfLValue(LHS); 23417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 23442acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *ResTy = ConvertType(E->getType()); 23457804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 234620eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 234720eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 && X, just emit X without inserting the control flow. 2348c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool LHSCondVal; 2349c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) { 2350c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (LHSCondVal) { // If we have 1 && X, just emit X. 23510946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 23527804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 23537804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 23540946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2355db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23567804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 235720eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 23587804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::Constant::getNullValue(ResTy); 23590946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2360db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23619615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 23629615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 236320eb09d562b80420a3328be789547af354bf3e36Chris Lattner 2364150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 2365150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2366f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is false, go to the failure (cont) block. 2367f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 2368f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2369f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2370f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be false. Start 2371f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 2372bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2, 23730032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2374f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2375f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 23763b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 2377db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2378150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 23797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 23807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2381150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2382db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 23847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2385f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2386f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2387f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 2388acd723666777b4ac1f79a97b6a300e6cf919d519Devang Patel if (CGF.getDebugInfo()) 2389acd723666777b4ac1f79a97b6a300e6cf919d519Devang Patel // There is no need to emit line number for unconditional branch. 2390acd723666777b4ac1f79a97b6a300e6cf919d519Devang Patel Builder.SetCurrentDebugLocation(llvm::DebugLoc()); 23917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 23927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2393db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 23957804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 23967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 23992acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *ResTy = ConvertType(E->getType()); 24007804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 240120eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 240220eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 || X, just emit X without inserting the control flow. 2403c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool LHSCondVal; 2404c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CGF.ConstantFoldsToSimpleInteger(E->getLHS(), LHSCondVal)) { 2405c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (!LHSCondVal) { // If we have 0 || X, just emit X. 24060946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 24077804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 24087804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 24090946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2410db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24117804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 241220eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 24137804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::ConstantInt::get(ResTy, 1); 24140946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2415db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24169615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 24179615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 2418db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2419150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 2420150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2421f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is true, go to the success (cont) block. 2422f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 2423f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2424f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2425f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be true. Start 2426f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 2427bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 2, 24280032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2429f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2430f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 24313b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 2432f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2433150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 243433da07db112f4877f6ab13e20db08b9bb86a0c2eAnders Carlsson 2435f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit the RHS condition as a bool value. 24367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 24377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2438db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2439150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2440db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 24427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2443db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2444f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2445f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 2446f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBlock(ContBlock); 24477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2448db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 24507804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 24517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 24527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 24537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 24542a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E->getLHS()); 2455a448fb2da03ece39978784793eea68760e8205a1Daniel Dunbar CGF.EnsureInsertPoint(); 24567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getRHS()); 24577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 24587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 24597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 24607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Other Operators 24617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 24627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 24639802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 24649802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// expression is cheap enough and side-effect-free enough to evaluate 24659802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// unconditionally instead of conditionally. This is used to convert control 24669802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// flow into selects in some cases. 2467df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stumpstatic bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 2468df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CodeGenFunction &CGF) { 2469f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne E = E->IgnoreParens(); 2470db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2471c6bea67efc38b075c401ebdb6ae97afa08cbb51dChris Lattner // Anything that is an integer or floating point constant is fine. 2472c6bea67efc38b075c401ebdb6ae97afa08cbb51dChris Lattner if (E->isConstantInitializer(CGF.getContext(), false)) 24739802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2474db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24759802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // Non-volatile automatic variables too, to get "cond ? X : Y" where 24769802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // X and Y are local variables. 24779802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 24789802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 2479df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (VD->hasLocalStorage() && !(CGF.getContext() 2480df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .getCanonicalType(VD->getType()) 2481df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .isVolatileQualified())) 24829802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2483db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24849802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return false; 24859802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner} 24869802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 24879802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 24887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter:: 248956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallVisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 24907f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 249156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 249256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // Bind the common expression if necessary. 249356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall CodeGenFunction::OpaqueValueMapping binding(CGF, E); 249456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 249556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *condExpr = E->getCond(); 249656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *lhsExpr = E->getTrueExpr(); 249756ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *rhsExpr = E->getFalseExpr(); 249856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall 249931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the condition constant folds and can be elided, try to avoid emitting 250031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the condition and the dead arm. 2501c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner bool CondExprBool; 2502c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (CGF.ConstantFoldsToSimpleInteger(condExpr, CondExprBool)) { 250356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Expr *live = lhsExpr, *dead = rhsExpr; 2504c2c90011a688c04a4e980282f08c267e081c4b00Chris Lattner if (!CondExprBool) std::swap(live, dead); 2505db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2506c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman // If the dead side doesn't have labels we need, just emit the Live part. 2507c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman if (!CGF.ContainsLabel(dead)) { 2508c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman Value *Result = Visit(live); 2509c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman 2510c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman // If the live part is a throw expression, it acts like it has a void 2511c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman // type, so evaluating it returns a null Value*. However, a conditional 2512c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman // with non-void type must return a non-null Value*. 2513c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman if (!Result && !E->getType()->isVoidType()) 2514c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman Result = llvm::UndefValue::get(CGF.ConvertType(E->getType())); 2515c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman 2516c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman return Result; 2517c8645e38bfe5ab46e424b7aaca53c064105c4265Eli Friedman } 2518c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner } 2519db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25206155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // OpenCL: If the condition is a vector, we can treat this condition like 25216155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // the select function. 25226155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (CGF.getContext().getLangOptions().OpenCL 252356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall && condExpr->getType()->isVectorType()) { 252456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *CondV = CGF.EmitScalarExpr(condExpr); 252556ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *LHS = Visit(lhsExpr); 252656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *RHS = Visit(rhsExpr); 25276155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 25282acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *condType = ConvertType(condExpr->getType()); 25292acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::VectorType *vecTy = cast<llvm::VectorType>(condType); 25306155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 25316155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman unsigned numElem = vecTy->getNumElements(); 25322acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *elemType = vecTy->getElementType(); 25336155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 25346155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman std::vector<llvm::Constant*> Zvals; 25356155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman for (unsigned i = 0; i < numElem; ++i) 253648431f9c8c2a09df80da5999358f9cf85553e9b2Chris Lattner Zvals.push_back(llvm::ConstantInt::get(elemType, 0)); 25376155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 25386155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *zeroVec = llvm::ConstantVector::get(Zvals); 25396155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec); 25406155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp = Builder.CreateSExt(TestMSB, 25416155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::VectorType::get(elemType, 25426155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman numElem), 25436155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman "sext"); 25446155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp2 = Builder.CreateNot(tmp); 25456155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 25466155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // Cast float to int to perform ANDs if necessary. 25476155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *RHSTmp = RHS; 25486155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *LHSTmp = LHS; 25496155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman bool wasCast = false; 25502acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType()); 25516155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (rhsVTy->getElementType()->isFloatTy()) { 25526155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType()); 25536155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman LHSTmp = Builder.CreateBitCast(LHS, tmp->getType()); 25546155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman wasCast = true; 25556155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 25566155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 25576155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2); 25586155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp); 25596155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond"); 25606155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (wasCast) 25616155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman tmp5 = Builder.CreateBitCast(tmp5, RHS->getType()); 2562db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25636155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman return tmp5; 25646155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 25656155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 25669802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // If this is a really simple expression (like x ? 4 : 5), emit this as a 25679802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // select instead of as control flow. We can only do this if it is cheap and 2568531a550531c144a58438f187816abbf1879e1c4eChris Lattner // safe to evaluate the LHS and RHS unconditionally. 256956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (isCheapEnoughToEvaluateUnconditionally(lhsExpr, CGF) && 257056ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall isCheapEnoughToEvaluateUnconditionally(rhsExpr, CGF)) { 257156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *CondV = CGF.EvaluateExprAsBool(condExpr); 257256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *LHS = Visit(lhsExpr); 257356ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall llvm::Value *RHS = Visit(rhsExpr); 25749802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 25759802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner } 2576db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2577be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 2578be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 25799615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 2580150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2581150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 258256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall CGF.EmitBranchOnBoolExpr(condExpr, LHSBlock, RHSBlock); 2583fb6fa30a9b06670deb14f862dddbc49a12552939Anders Carlsson 25847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(LHSBlock); 2585150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 258656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Value *LHS = Visit(lhsExpr); 2587150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2588db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHSBlock = Builder.GetInsertBlock(); 2590150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall Builder.CreateBr(ContBlock); 2591db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 2593150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 259456ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall Value *RHS = Visit(rhsExpr); 2595150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2596db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2597150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall RHSBlock = Builder.GetInsertBlock(); 25987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 2599db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 260048daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman // If the LHS or RHS is a throw expression, it will be legitimately null. 260148daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!LHS) 260248daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return RHS; 260348daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!RHS) 260448daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return LHS; 2605db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 26067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Create a PHI node for the real part. 2607bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), 2, "cond"); 26087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(LHS, LHSBlock); 26097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHS, RHSBlock); 26107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return PN; 26117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 26127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 26137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 26147976932a1c256d447316ffac58e9821417725e34Eli Friedman return Visit(E->getChosenSubExpr(CGF.getContext())); 26157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 26167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 26172202bce80fc72d067cbe67dc1512f7b45351fd31Chris LattnerValue *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 26184fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 2619ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 2620ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 2621ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson // If EmitVAArg fails, we fall back to the LLVM instruction. 2622db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (!ArgPtr) 2623ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 2624ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 26257f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // FIXME Volatility. 2626ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateLoad(ArgPtr); 26277c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson} 26287c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 26296b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCallValue *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *block) { 26306b5a61b6dc400027fd793dcadceeb9da944a37eaJohn McCall return CGF.EmitBlockLiteral(block); 2631df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump} 2632df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 263361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya LattnerValue *ScalarExprEmitter::VisitAsTypeExpr(AsTypeExpr *E) { 263461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Value *Src = CGF.EmitScalarExpr(E->getSrcExpr()); 26352acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *DstTy = ConvertType(E->getType()); 263661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 263761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // Going from vec4->vec3 or vec3->vec4 is a special case and requires 263861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // a shuffle vector instead of a bitcast. 26392acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *SrcTy = Src->getType(); 264061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if (isa<llvm::VectorType>(DstTy) && isa<llvm::VectorType>(SrcTy)) { 264161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner unsigned numElementsDst = cast<llvm::VectorType>(DstTy)->getNumElements(); 264261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner unsigned numElementsSrc = cast<llvm::VectorType>(SrcTy)->getNumElements(); 264361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if ((numElementsDst == 3 && numElementsSrc == 4) 264461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner || (numElementsDst == 4 && numElementsSrc == 3)) { 264561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 264661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 264761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // In the case of going from int4->float3, a bitcast is needed before 264861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // doing a shuffle. 26492acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *srcElemTy = 265061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner cast<llvm::VectorType>(SrcTy)->getElementType(); 26512acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *dstElemTy = 265261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner cast<llvm::VectorType>(DstTy)->getElementType(); 265361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 265461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if ((srcElemTy->isIntegerTy() && dstElemTy->isFloatTy()) 265561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner || (srcElemTy->isFloatTy() && dstElemTy->isIntegerTy())) { 265661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner // Create a float type of the same size as the source or destination. 26572acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::VectorType *newSrcTy = llvm::VectorType::get(dstElemTy, 265861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner numElementsSrc); 265961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 266061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Src = Builder.CreateBitCast(Src, newSrcTy, "astypeCast"); 266161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner } 266261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 266361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner llvm::Value *UnV = llvm::UndefValue::get(Src->getType()); 266461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 26655f9e272e632e951b1efe824cd16acb4d96077930Chris Lattner SmallVector<llvm::Constant*, 3> Args; 266661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(Builder.getInt32(0)); 266761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(Builder.getInt32(1)); 266861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(Builder.getInt32(2)); 266961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 267061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner if (numElementsDst == 4) 267161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner Args.push_back(llvm::UndefValue::get( 267261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner llvm::Type::getInt32Ty(CGF.getLLVMContext()))); 267361eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 267461eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner llvm::Constant *Mask = llvm::ConstantVector::get(Args); 267561eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 267661eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner return Builder.CreateShuffleVector(Src, UnV, Mask, "astype"); 267761eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner } 267861eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner } 267961eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 268061eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner return Builder.CreateBitCast(Src, DstTy, "astype"); 268161eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner} 268261eee0ca33b29e102f11bab77c8b74cc00e2392bTanya Lattner 2683276b061970939293f1abaf694bd3ef05b2cbda79Eli FriedmanValue *ScalarExprEmitter::VisitAtomicExpr(AtomicExpr *E) { 2684276b061970939293f1abaf694bd3ef05b2cbda79Eli Friedman return CGF.EmitAtomicExpr(E).getScalarVal(); 2685276b061970939293f1abaf694bd3ef05b2cbda79Eli Friedman} 2686276b061970939293f1abaf694bd3ef05b2cbda79Eli Friedman 26877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 26887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Entry Point into this File 26897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 26907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2691db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitScalarExpr - Emit the computation of the specified expression of scalar 2692db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type, ignoring the result. 26937f79f9be5916c51c35da4f126b7c12596a101607Mike StumpValue *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 26947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E && !hasAggregateLLVMType(E->getType()) && 26957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Invalid scalar expression to emit"); 2696db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 26975de7a0e8800b89780e565c1013e566414f11546aDevang Patel if (isa<CXXDefaultArgExpr>(E)) 2698aa11289f754d220c9c155b68a4f84cdcfcefef6aDevang Patel disableDebugInfo(); 26995de7a0e8800b89780e565c1013e566414f11546aDevang Patel Value *V = ScalarExprEmitter(*this, IgnoreResultAssign) 27007f79f9be5916c51c35da4f126b7c12596a101607Mike Stump .Visit(const_cast<Expr*>(E)); 27015de7a0e8800b89780e565c1013e566414f11546aDevang Patel if (isa<CXXDefaultArgExpr>(E)) 2702aa11289f754d220c9c155b68a4f84cdcfcefef6aDevang Patel enableDebugInfo(); 27035de7a0e8800b89780e565c1013e566414f11546aDevang Patel return V; 27047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 27053707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 27063707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 27073707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 27084f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 27094f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 27103707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 27113707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner "Invalid scalar expression to emit"); 27123707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 27133707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 27144f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 2715db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 2716db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 2717db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 27184f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 27194f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, 27204f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 27219b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 27224f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner "Invalid complex -> scalar conversion"); 27234f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 27244f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner DstTy); 27254f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 2726cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 27278c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 27288c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *CodeGenFunction:: 27298c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 27308c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 27318c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre); 27328c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 27338c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2734820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz JahanianLValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 2735820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian llvm::Value *V; 2736820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // object->isa or (*object).isa 2737820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // Generate code as for: *(Class*)object 27385ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian // build Class* type 27392acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *ClassPtrTy = ConvertType(E->getType()); 27405ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian 2741820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Expr *BaseExpr = E->getBase(); 27427eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (BaseExpr->isRValue()) { 27435ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = CreateTempAlloca(ClassPtrTy, "resval"); 27445ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian llvm::Value *Src = EmitScalarExpr(BaseExpr); 27455ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian Builder.CreateStore(Src, V); 27469f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue( 2747545d996ec5a3113f046944f11b27cc2d6cb055b4John McCall MakeAddrLValue(V, E->getType())); 27489f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar } else { 27499f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar if (E->isArrow()) 27509f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr); 27519f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar else 27529f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = EmitLValue(BaseExpr).getAddress(); 27535ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 2754820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 2755820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // build Class* type 2756820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian ClassPtrTy = ClassPtrTy->getPointerTo(); 2757820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian V = Builder.CreateBitCast(V, ClassPtrTy); 27589f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(V, E->getType()); 2759820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian} 2760820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 27616a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 27622a41637a995affa1563f4d82a8b026e326a2faa0John McCallLValue CodeGenFunction::EmitCompoundAssignmentLValue( 27636a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E) { 27646a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor ScalarExprEmitter Scalar(*this); 2765d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *Result = 0; 27666a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor switch (E->getOpcode()) { 27676a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#define COMPOUND_OP(Op) \ 27682de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_##Op##Assign: \ 27696a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 2770d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result) 27716a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Mul); 27726a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Div); 27736a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Rem); 27746a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Add); 27756a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Sub); 27766a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shl); 27776a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shr); 27786a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(And); 27796a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Xor); 27806a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Or); 27816a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#undef COMPOUND_OP 27826a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 27832de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemD: 27842de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemI: 27852de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 27862de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Div: 27872de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Rem: 27882de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 27892de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 27902de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shl: 27912de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shr: 27922de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LT: 27932de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GT: 27942de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LE: 27952de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GE: 27962de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_EQ: 27972de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_NE: 27982de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_And: 27992de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Xor: 28002de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Or: 28012de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LAnd: 28022de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LOr: 28032de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Assign: 28042de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Comma: 2805b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Not valid compound assignment operators"); 28066a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor } 28076a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 28086a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor llvm_unreachable("Unhandled compound assignment operator"); 28096a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 2810