CGExprScalar.cpp revision 683564a7a93c952f1fbe573b55c542418d29d859
17f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===--- CGExprScalar.cpp - Emit LLVM Code for Scalar Exprs ---------------===// 27f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 37f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// The LLVM Compiler Infrastructure 47f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 77f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 87f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 97f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// This contains code to emit Expr nodes with scalar LLVM types as LLVM code. 117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// 127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1478ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel#include "clang/Frontend/CodeGenOptions.h" 157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "CodeGenFunction.h" 164c40d98ab7acf5f27fa89b17bd8fc0ef7683df37John McCall#include "CGCXXABI.h" 17f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian#include "CGObjCRuntime.h" 187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "CodeGenModule.h" 1978ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel#include "CGDebugInfo.h" 20de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 2198c5ead87d720d8b68b6f236c3c3579a388fc882Daniel Dunbar#include "clang/AST/DeclObjC.h" 2219cc4abea06a9b49e0e16a50d335c064cd723572Anders Carlsson#include "clang/AST/RecordLayout.h" 23de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/StmtVisitor.h" 2425ddea7f7835c4b1804e458a5c866cde0097430aChris Lattner#include "clang/Basic/TargetInfo.h" 257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "llvm/Constants.h" 267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#include "llvm/Function.h" 2785f9bceab1542aafff012d4d28e998f4ba16e362Anders Carlsson#include "llvm/GlobalVariable.h" 287c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson#include "llvm/Intrinsics.h" 292add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump#include "llvm/Module.h" 30f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner#include "llvm/Support/CFG.h" 314e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump#include "llvm/Target/TargetData.h" 32c89bf69c9289d2b2305f2c267daacc7312391898Chris Lattner#include <cstdarg> 336aad91a43e26118c824d976661077819265d9bc0Ted Kremenek 347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing namespace clang; 357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing namespace CodeGen; 367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerusing llvm::Value; 377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Scalar Expression Emitter 407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4279ba2a6379f87fa137377c3f55ff993b9e5cc144Benjamin Kramernamespace { 437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerstruct BinOpInfo { 447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS; 457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS; 461f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner QualType Ty; // Computation Type. 479a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinaryOperator::Opcode Opcode; // Opcode of BinOp to perform 489a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const Expr *E; // Entire expr, for error unsupported. May not be binop. 497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 51404cd1669c3ba138a9ae0a619bd689cce5aae271John McCallstatic bool MustVisitNullValue(const Expr *E) { 52404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall // If a null pointer expression's type is the C++0x nullptr_t, then 53404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall // it's not necessarily a simple constant and it must be evaluated 54404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall // for its potential side effects. 55404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall return E->getType()->isNullPtrType(); 56404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall} 57404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 5885b4521e34dcd4a0a4a1f0819e1123128e5a3125Benjamin Kramerclass ScalarExprEmitter 597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner : public StmtVisitor<ScalarExprEmitter, Value*> { 607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction &CGF; 6145d196b8387dcefc4df26cda114fa34c6528e928Daniel Dunbar CGBuilderTy &Builder; 627f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreResultAssign; 63a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson llvm::LLVMContext &VMContext; 647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattnerpublic: 657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 667f79f9be5916c51c35da4f126b7c12596a101607Mike Stump ScalarExprEmitter(CodeGenFunction &cgf, bool ira=false) 67db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump : CGF(cgf), Builder(CGF.Builder), IgnoreResultAssign(ira), 68a1cf15f4680e5cf39e72e28c5ea854fcba792e84Owen Anderson VMContext(cgf.getLLVMContext()) { 697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 70db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Utilities 737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 757f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool TestAndClearIgnoreResultAssign() { 769c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner bool I = IgnoreResultAssign; 779c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner IgnoreResultAssign = false; 789c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return I; 799c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner } 807f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); } 827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); } 83b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue EmitCheckedLValue(const Expr *E) { return CGF.EmitCheckedLValue(E); } 847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(LValue LV, QualType T) { 869b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitLoadOfLValue(LV, T).getScalarVal(); 877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 88db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// EmitLoadOfLValue - Given an expression with complex type that represents a 907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// value l-value, this method emits the address of the l-value, then loads 917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner /// and returns the result. 927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitLoadOfLValue(const Expr *E) { 93b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump return EmitLoadOfLValue(EmitCheckedLValue(E), E->getType()); 947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 95db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 969abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner /// EmitConversionToBool - Convert the specified expression value to a 973420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner /// boolean (i1) truth value. This is equivalent to "Val != 0". 989abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner Value *EmitConversionToBool(Value *Src, QualType DstTy); 99db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1003707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// EmitScalarConversion - Emit a conversion from the specified type to the 1013707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner /// specified destination type, both of which are LLVM scalar types. 1024f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy); 1034f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 1044f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner /// EmitComplexToScalarConversion - Emit a conversion from the specified 105db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump /// complex type to the specified destination type, where the destination type 106db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump /// is an LLVM scalar type. 1074f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 1084f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy); 109df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 110a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson /// EmitNullValue - Emit a value that corresponds to null for the given type. 111a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson Value *EmitNullValue(QualType Ty); 112a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson 113daa8e4e888758d55a7a759dd4a91b83921cef222John McCall /// EmitFloatToBoolConversion - Perform an FP to boolean conversion. 114daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Value *EmitFloatToBoolConversion(Value *V) { 115daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // Compare against 0.0 for fp scalars. 116daa8e4e888758d55a7a759dd4a91b83921cef222John McCall llvm::Value *Zero = llvm::Constant::getNullValue(V->getType()); 117daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return Builder.CreateFCmpUNE(V, Zero, "tobool"); 118daa8e4e888758d55a7a759dd4a91b83921cef222John McCall } 119daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 120daa8e4e888758d55a7a759dd4a91b83921cef222John McCall /// EmitPointerToBoolConversion - Perform a pointer to boolean conversion. 121daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Value *EmitPointerToBoolConversion(Value *V) { 122daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Value *Zero = llvm::ConstantPointerNull::get( 123daa8e4e888758d55a7a759dd4a91b83921cef222John McCall cast<llvm::PointerType>(V->getType())); 124daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return Builder.CreateICmpNE(V, Zero, "tobool"); 125daa8e4e888758d55a7a759dd4a91b83921cef222John McCall } 126daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 127daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Value *EmitIntToBoolConversion(Value *V) { 128daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // Because of the type rules of C, we often end up computing a 129daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // logical value, then zero extending it to int, then wanting it 130daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // as a logical value again. Optimize this common case. 131daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(V)) { 132daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (ZI->getOperand(0)->getType() == Builder.getInt1Ty()) { 133daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Value *Result = ZI->getOperand(0); 134daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // If there aren't any more uses, zap the instruction to save space. 135daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // Note that there can be more uses, for example if this 136daa8e4e888758d55a7a759dd4a91b83921cef222John McCall // is the result of an assignment. 137daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (ZI->use_empty()) 138daa8e4e888758d55a7a759dd4a91b83921cef222John McCall ZI->eraseFromParent(); 139daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return Result; 140daa8e4e888758d55a7a759dd4a91b83921cef222John McCall } 141daa8e4e888758d55a7a759dd4a91b83921cef222John McCall } 142daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 143daa8e4e888758d55a7a759dd4a91b83921cef222John McCall const llvm::IntegerType *Ty = cast<llvm::IntegerType>(V->getType()); 144daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Value *Zero = llvm::ConstantInt::get(Ty, 0); 145daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return Builder.CreateICmpNE(V, Zero, "tobool"); 146daa8e4e888758d55a7a759dd4a91b83921cef222John McCall } 147daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 1487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 1497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Visitor Methods 1507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner //===--------------------------------------------------------------------===// 1517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 152af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *Visit(Expr *E) { 153af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian llvm::DenseMap<const Expr *, llvm::Value *>::iterator I = 154af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian CGF.ConditionalSaveExprs.find(E); 155af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian if (I != CGF.ConditionalSaveExprs.end()) 156af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian return I->second; 157af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian 158af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian return StmtVisitor<ScalarExprEmitter, Value*>::Visit(E); 159af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian } 160af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian 1617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitStmt(Stmt *S) { 1627a9d49fd2bfac00e905b361ba76d26ab5b6c3b09Ted Kremenek S->dump(CGF.getContext().getSourceManager()); 1637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(0 && "Stmt can't have complex result type!"); 1647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 1657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitExpr(Expr *S); 167f51dc64f90851f636302dbaaf3f52c0524cdac36Fariborz Jahanian 168af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *VisitParenExpr(ParenExpr *PE) { 169af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian return Visit(PE->getSubExpr()); 170af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian } 1717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Leaves. 1737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitIntegerLiteral(const IntegerLiteral *E) { 1744a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(VMContext, E->getValue()); 1757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitFloatingLiteral(const FloatingLiteral *E) { 177bc0a2226c7fcd18b29b6846049e2cfcb872d3593Owen Anderson return llvm::ConstantFP::get(VMContext, E->getValue()); 1787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 1797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCharacterLiteral(const CharacterLiteral *E) { 1804a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 181e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman } 182e7579b57eb3eabfd3545b86320fb67466730e9fcNate Begeman Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) { 1834a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 1847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 185ed8abf18329df67b0abcbb3a10458bd8c1d2a595Douglas Gregor Value *VisitCXXScalarValueInitExpr(const CXXScalarValueInitExpr *E) { 186a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1877267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis } 1883f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson Value *VisitGNUNullExpr(const GNUNullExpr *E) { 189a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 1903f70456b8adb0405ef2a47d51f9fc2d5937ae8aeAnders Carlsson } 1910027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Value *VisitOffsetOfExpr(OffsetOfExpr *E); 1920518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl Value *VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E); 1930ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar Value *VisitAddrLabelExpr(const AddrLabelExpr *E) { 194d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner llvm::Value *V = CGF.GetAddrOfLabel(E->getLabel()); 195d9becd1846e2c72bf6ad283faa1b048f33dd3afeChris Lattner return Builder.CreateBitCast(V, ConvertType(E->getType())); 1960ffb125996336fc7602b162c0a9e392f1a93060fDaniel Dunbar } 197db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1989370c8f4af43a98a6f16e65f5d88d58db846e374Douglas Gregor Value *VisitSizeOfPackExpr(SizeOfPackExpr *E) { 1999370c8f4af43a98a6f16e65f5d88d58db846e374Douglas Gregor return llvm::ConstantInt::get(ConvertType(E->getType()), 2009370c8f4af43a98a6f16e65f5d88d58db846e374Douglas Gregor E->getPackLength()); 2019370c8f4af43a98a6f16e65f5d88d58db846e374Douglas Gregor } 2029370c8f4af43a98a6f16e65f5d88d58db846e374Douglas Gregor 2037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // l-values. 2047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitDeclRefExpr(DeclRefExpr *E) { 20528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 206189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall if (!E->Evaluate(Result, CGF.getContext())) 207189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall return EmitLoadOfLValue(E); 208189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 209189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall assert(!Result.HasSideEffects && "Constant declref with side-effect?!"); 210189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 211189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall llvm::Constant *C; 212189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall if (Result.Val.isInt()) { 213189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall C = llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 214189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall } else if (Result.Val.isFloat()) { 215189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall C = llvm::ConstantFP::get(VMContext, Result.Val.getFloat()); 216189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall } else { 217189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall return EmitLoadOfLValue(E); 21828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 219189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 220189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall // Make sure we emit a debug reference to the global variable. 221189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall if (VarDecl *VD = dyn_cast<VarDecl>(E->getDecl())) { 222189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall if (!CGF.getContext().DeclMustBeEmitted(VD)) 223189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall CGF.EmitDeclRefExprDbgValue(E, C); 224189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall } else if (isa<EnumConstantDecl>(E->getDecl())) { 225189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall CGF.EmitDeclRefExprDbgValue(E, C); 226189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall } 227189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall 228189d6ef40eff11b83b2cda941d5ed89a5cef09b2John McCall return C; 2297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 230db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCSelectorExpr(ObjCSelectorExpr *E) { 231db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCSelectorExpr(E); 2329c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 233db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCProtocolExpr(ObjCProtocolExpr *E) { 234db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump return CGF.EmitObjCProtocolExpr(E); 2359c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 236db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump Value *VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 2379c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return EmitLoadOfLValue(E); 2389c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 2390a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar Value *VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 240f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(E->getObjectKind() == OK_Ordinary && 241f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall "reached property reference without lvalue-to-rvalue"); 24285c59edda02df48fae8dc85049743319bc6e7e89Daniel Dunbar return EmitLoadOfLValue(E); 2439c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar } 2449c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar Value *VisitObjCMessageExpr(ObjCMessageExpr *E) { 2459c3fc703b29a31d40bcf5027dbb4784dd393804eDaniel Dunbar return CGF.EmitObjCMessageExpr(E).getScalarVal(); 2460a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar } 2470a04d77bde7e3a661c2b41b60630d125d09ed6efDaniel Dunbar 24883dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian Value *VisitObjCIsaExpr(ObjCIsaExpr *E) { 249820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian LValue LV = CGF.EmitObjCIsaExpr(E); 250820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Value *V = CGF.EmitLoadOfLValue(LV, E->getType()).getScalarVal(); 25183dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian return V; 25283dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian } 25383dc32594cde6bd083bd8b98b24bde2346585cadFariborz Jahanian 2547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E); 255d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value *VisitShuffleVectorExpr(ShuffleVectorExpr *E); 25628665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Value *VisitMemberExpr(MemberExpr *E); 257213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman Value *VisitExtVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); } 258be20bb558cae5352898e6a913e29d24d20134841Chris Lattner Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 259be20bb558cae5352898e6a913e29d24d20134841Chris Lattner return EmitLoadOfLValue(E); 260be20bb558cae5352898e6a913e29d24d20134841Chris Lattner } 26135634f5ed67966c9f1fde38420e79cc6515cd673Devang Patel 2620533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *VisitInitListExpr(InitListExpr *E); 263db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2643498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor Value *VisitImplicitValueInitExpr(const ImplicitValueInitExpr *E) { 2653cb18bcefe39756f3b079fa1a62b4c9cbf6a592fAnders Carlsson return CGF.CGM.EmitNullConstant(E->getType()); 2663498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor } 267d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *VisitCastExpr(CastExpr *E) { 268c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman // Make sure to evaluate VLA bounds now so that we have them for later. 269745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian if (E->getType()->isVariablyModifiedType()) 270745da3a5bb4ea35f93f50301e7fbbb7d78d3b6bbFariborz Jahanian CGF.EmitVLASize(E->getType()); 271c62aad8f45ec3dd893376bd1c51e5e8019a76d8eEli Friedman 272592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson return EmitCastExpr(E); 2737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 274d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *EmitCastExpr(CastExpr *E); 2757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitCallExpr(const CallExpr *E) { 277e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson if (E->getCallReturnType()->isReferenceType()) 278e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson return EmitLoadOfLValue(E); 279db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2809b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitCallExpr(E).getScalarVal(); 2817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2828f2926b73ed635afecd020da787af6a837601a2bDaniel Dunbar 2833379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner Value *VisitStmtExpr(const StmtExpr *E); 2844e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump 285a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike Stump Value *VisitBlockDeclRefExpr(const BlockDeclRefExpr *E); 286db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Unary Operators. 2887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostDec(const UnaryOperator *E) { 2898c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2908c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, false); 2917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPostInc(const UnaryOperator *E) { 2938c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2948c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, false); 2957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreDec(const UnaryOperator *E) { 2978c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 2988c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, false, true); 2997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPreInc(const UnaryOperator *E) { 3018c11a65c18ae607b7073e1e451264492d2297726Chris Lattner LValue LV = EmitLValue(E->getSubExpr()); 3028c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return EmitScalarPrePostIncDec(E, LV, true, true); 3037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3048c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 305683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *EmitAddConsiderOverflowBehavior(const UnaryOperator *E, 306683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *InVal, 307683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *NextVal, 308683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev bool IsInc); 309683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 3108c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 3118c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre); 3128c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 3138c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 3147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryAddrOf(const UnaryOperator *E) { 3155808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall if (isa<MemberPointerType>(E->getType())) // never sugared 3165808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall return CGF.CGM.getMemberPointerConstant(E); 3175808ce43f8d7e71f5acacc9ca320268c4f37565aJohn McCall 3187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLValue(E->getSubExpr()).getAddress(); 3197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 320fd569004b78124c1041feee75a1e311166268c8dJohn McCall Value *VisitUnaryDeref(const UnaryOperator *E) { 321fd569004b78124c1041feee75a1e311166268c8dJohn McCall if (E->getType()->isVoidType()) 322fd569004b78124c1041feee75a1e311166268c8dJohn McCall return Visit(E->getSubExpr()); // the actual value should be unused 323fd569004b78124c1041feee75a1e311166268c8dJohn McCall return EmitLoadOfLValue(E); 324fd569004b78124c1041feee75a1e311166268c8dJohn McCall } 3257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPlus(const UnaryOperator *E) { 3267f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // This differs from gcc, though, most likely due to a bug in gcc. 3277f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 3287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 3297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryMinus (const UnaryOperator *E); 3317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryNot (const UnaryOperator *E); 3327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryLNot (const UnaryOperator *E); 33346f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryReal (const UnaryOperator *E); 33446f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryImag (const UnaryOperator *E); 3357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryExtension(const UnaryOperator *E) { 3367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 3377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3388ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 3395f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson // C++ 34004421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 34104421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 34204421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 3435f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson Value *VisitCXXThisExpr(CXXThisExpr *TE) { 3445f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson return CGF.LoadCXXThis(); 345db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 346db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3474765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall Value *VisitExprWithCleanups(ExprWithCleanups *E) { 3484765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall return CGF.EmitExprWithCleanups(E).getScalarVal(); 3497f6ad153565245026c7569314f65a4d4ff4ac41fAnders Carlsson } 350a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson Value *VisitCXXNewExpr(const CXXNewExpr *E) { 351a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson return CGF.EmitCXXNewExpr(E); 352a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson } 35360e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) { 35460e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson CGF.EmitCXXDeleteExpr(E); 35560e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson return 0; 35660e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson } 3579dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman Value *VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 3580dfd848fa4c9664852ba8c929a8bd3fce93ddca2Sebastian Redl return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue()); 3599dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman } 360db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3616ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet Value *VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *E) { 362f187237d916afa97c491ac32fe98be7d335c5b63Francois Pichet return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 3636ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet } 3646ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet 365a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) { 366a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // C++ [expr.pseudo]p1: 367db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // The result shall only be used as the operand for the function call 368a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // operator (), and the result of such a call has type void. The only 369a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // effect is the evaluation of the postfix-expression before the dot or 370a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // arrow. 371a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor CGF.EmitScalarExpr(E->getBase()); 372a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor return 0; 373a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor } 374db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 375c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 376a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 377c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson } 378756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 379756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson Value *VisitCXXThrowExpr(const CXXThrowExpr *E) { 380756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson CGF.EmitCXXThrowExpr(E); 381756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson return 0; 382756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson } 383756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 38498294def01c97e127fa6d812ebd944d37212828aSebastian Redl Value *VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) { 38598294def01c97e127fa6d812ebd944d37212828aSebastian Redl return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue()); 38698294def01c97e127fa6d812ebd944d37212828aSebastian Redl } 38798294def01c97e127fa6d812ebd944d37212828aSebastian Redl 3887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Binary Operators. 3897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitMul(const BinOpInfo &Ops) { 390f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 391a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 392a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 393a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul"); 394a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 395a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 396a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 397a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 398a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 399a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 400a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 401f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 40287415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul"); 4037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 4047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4058023030f76d334355b73d9c675d3870858aaf4fdChris Lattner bool isTrapvOverflowBehavior() { 4068023030f76d334355b73d9c675d3870858aaf4fdChris Lattner return CGF.getContext().getLangOptions().getSignedOverflowBehavior() 4078023030f76d334355b73d9c675d3870858aaf4fdChris Lattner == LangOptions::SOB_Trapping; 4088023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 4092add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Create a binary op that checks for overflow. 4102add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Currently only supports +, - and *. 4112add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); 4128023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Emit the overflow BB when -ftrapv option is activated. 4138023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitOverflowBB(llvm::BasicBlock *overflowBB) { 4148023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(overflowBB); 4158023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Function *Trap = CGF.CGM.getIntrinsic(llvm::Intrinsic::trap); 4168023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCall(Trap); 4178023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateUnreachable(); 4188023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 4198023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Check for undefined division and modulus behaviors. 4208023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops, 4218023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero,bool isDiv); 4227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitDiv(const BinOpInfo &Ops); 4237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitRem(const BinOpInfo &Ops); 4247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAdd(const BinOpInfo &Ops); 4257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitSub(const BinOpInfo &Ops); 4267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShl(const BinOpInfo &Ops); 4277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShr(const BinOpInfo &Ops); 4287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAnd(const BinOpInfo &Ops) { 4297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 4307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitXor(const BinOpInfo &Ops) { 4327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 4337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitOr (const BinOpInfo &Ops) { 4357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 4367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4381f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo EmitBinOps(const BinaryOperator *E); 4396a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 4406a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*F)(const BinOpInfo &), 441d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result); 4426a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 4433ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *EmitCompoundAssign(const CompoundAssignOperator *E, 4441f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 4451f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 4461f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Binary operators and binary compound assignment operators. 4471f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#define HANDLEBINOP(OP) \ 4483ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP(const BinaryOperator *E) { \ 4493ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return Emit ## OP(EmitBinOps(E)); \ 4503ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner } \ 4513ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 4523ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 4531f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 4547177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Mul) 4557177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Div) 4567177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Rem) 4577177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Add) 4587177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Sub) 4597177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shl) 4607177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shr) 4617177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(And) 4627177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Xor) 4637177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Or) 4641f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#undef HANDLEBINOP 4658c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 4667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Comparisons. 4677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 4687f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc); 4697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#define VISITCOMP(CODE, UI, SI, FP) \ 4707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBin##CODE(const BinaryOperator *E) { \ 4717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 4727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::FCmpInst::FP); } 4737177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT) 4747177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT) 4757177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE) 4767177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE) 4777177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ) 4787177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE) 4797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#undef VISITCOMP 480db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinAssign (const BinaryOperator *E); 4827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLAnd (const BinaryOperator *E); 4847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLOr (const BinaryOperator *E); 4857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinComma (const BinaryOperator *E); 4867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 48725b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); } 48825b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); } 48925b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman 4907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Other Operators. 491df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump Value *VisitBlockExpr(const BlockExpr *BE); 4927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitConditionalOperator(const ConditionalOperator *CO); 4937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitChooseExpr(ChooseExpr *CE); 4947c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson Value *VisitVAArgExpr(VAArgExpr *VE); 4957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 4967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return CGF.EmitObjCStringLiteral(E); 4977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 4997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} // end anonymous namespace. 5007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Utilities 5037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 5047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5059abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner/// EmitConversionToBool - Convert the specified expression value to a 5063420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner/// boolean (i1) truth value. This is equivalent to "Val != 0". 5079abc84e7ac4db891209fe67cc3a8c9690dc886efChris LattnerValue *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 508467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs"); 509db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 510daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (SrcType->isRealFloatingType()) 511daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitFloatToBoolConversion(Src); 512db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5130bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType)) 5140bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT); 515db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 516d1d66bcd6914ff82abdfa88dd25bb0b74cde3b99Daniel Dunbar assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 5179abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner "Unknown scalar type to convert"); 518db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 519daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (isa<llvm::IntegerType>(Src->getType())) 520daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitIntToBoolConversion(Src); 521db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 522daa8e4e888758d55a7a759dd4a91b83921cef222John McCall assert(isa<llvm::PointerType>(Src->getType())); 523daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitPointerToBoolConversion(Src); 5249abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner} 5259abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 5263707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 5273707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 5284f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 5294f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstType) { 5309619662a1d42e2008b865d3459c0677e149dad1bChris Lattner SrcType = CGF.getContext().getCanonicalType(SrcType); 5319619662a1d42e2008b865d3459c0677e149dad1bChris Lattner DstType = CGF.getContext().getCanonicalType(DstType); 5323707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (SrcType == DstType) return Src; 533db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 534cf289083ab007264fa3ea96d92f133339aee5d2dChris Lattner if (DstType->isVoidType()) return 0; 535db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5363707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 537ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstType->isBooleanType()) 538ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return EmitConversionToBool(Src, SrcType); 539db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5403707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner const llvm::Type *DstTy = ConvertType(DstType); 5413707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 5423707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Ignore conversions like int -> uint. 5433707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (Src->getType() == DstTy) 5443707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Src; 5453707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 546db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle pointer conversions next: pointers can only be converted to/from 547db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // other pointers and integers. Check for pointer types in terms of LLVM, as 548db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // some native types (like Obj-C id) may map to a pointer type. 549270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(DstTy)) { 5503707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // The source value may be an integer, or a pointer. 551191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson if (isa<llvm::PointerType>(Src->getType())) 5523707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Builder.CreateBitCast(Src, DstTy, "conv"); 553191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 5543707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 55525615424741bcce31fe52c896f76268f0307f00dEli Friedman // First, convert to the correct width so that we control the kind of 55625615424741bcce31fe52c896f76268f0307f00dEli Friedman // extension. 55777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 55825615424741bcce31fe52c896f76268f0307f00dEli Friedman bool InputSigned = SrcType->isSignedIntegerType(); 55925615424741bcce31fe52c896f76268f0307f00dEli Friedman llvm::Value* IntResult = 56025615424741bcce31fe52c896f76268f0307f00dEli Friedman Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 56125615424741bcce31fe52c896f76268f0307f00dEli Friedman // Then, cast to pointer. 56225615424741bcce31fe52c896f76268f0307f00dEli Friedman return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 5633707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 564db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 565270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(Src->getType())) { 5663707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Must be an ptr to int cast. 5673707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 56850b5a30db40322880340e957ad7d6d8d60bb4c5bAnders Carlsson return Builder.CreatePtrToInt(Src, DstTy, "conv"); 5693707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 570db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 571213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // A scalar can be splatted to an extended vector of the same element type 5722ef13e5abef0570a9f567b4671367275c05d4d34Nate Begeman if (DstType->isExtVectorType() && !SrcType->isVectorType()) { 5736fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Cast the scalar to element type 574183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType EltTy = DstType->getAs<ExtVectorType>()->getElementType(); 5756fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 5766fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 5776fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Insert the element in element zero of an undef vector 57803e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::Value *UnV = llvm::UndefValue::get(DstTy); 57977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 5806fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 5816fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 5826fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Splat the element across to all elements 5836fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 5846fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 5856fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman for (unsigned i = 0; i < NumElements; i++) 58677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 0)); 587db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5884a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 5896fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 5906fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman return Yay; 5916fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman } 5924119d1aeca8016654d381ce079864058d1709571Nate Begeman 5933b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner // Allow bitcast from vector to integer/fp of the same size. 5947019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson if (isa<llvm::VectorType>(Src->getType()) || 5953b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner isa<llvm::VectorType>(DstTy)) 5967019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson return Builder.CreateBitCast(Src, DstTy, "conv"); 597db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5983707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Finally, we have the arithmetic types: real int/float. 5993707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(Src->getType())) { 6003707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner bool InputSigned = SrcType->isSignedIntegerType(); 601b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (isa<llvm::IntegerType>(DstTy)) 602b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 603b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else if (InputSigned) 604b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateSIToFP(Src, DstTy, "conv"); 605b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 606b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateUIToFP(Src, DstTy, "conv"); 6073707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 608db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 609f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(Src->getType()->isFloatingPointTy() && "Unknown real conversion"); 6103707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(DstTy)) { 611b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstType->isSignedIntegerType()) 612b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToSI(Src, DstTy, "conv"); 613b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 614b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToUI(Src, DstTy, "conv"); 6153707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 6163707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 617f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(DstTy->isFloatingPointTy() && "Unknown real conversion"); 618b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstTy->getTypeID() < Src->getType()->getTypeID()) 619b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPTrunc(Src, DstTy, "conv"); 620b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 621b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPExt(Src, DstTy, "conv"); 6223707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 6233707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 624db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 625db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 626db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 6274f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter:: 6284f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerEmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 6294f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy) { 630ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Get the source element type. 631183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall SrcTy = SrcTy->getAs<ComplexType>()->getElementType(); 632db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 633ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 634ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstTy->isBooleanType()) { 635ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Complex != 0 -> (Real != 0) | (Imag != 0) 636ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 637ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 638ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return Builder.CreateOr(Src.first, Src.second, "tobool"); 639ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner } 640db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 6414f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 6424f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // the imaginary part of the complex value is discarded and the value of the 6434f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // real part is converted according to the conversion rules for the 644db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // corresponding real type. 6454f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return EmitScalarConversion(Src.first, SrcTy, DstTy); 6464f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 6474f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 648a40a9f31218c743e366322e34b59f0d4d4414198Anders CarlssonValue *ScalarExprEmitter::EmitNullValue(QualType Ty) { 6490bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) 6500bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 6510bab0cdab751248ca389a5592bcb70eac5d39260John McCall 6520bab0cdab751248ca389a5592bcb70eac5d39260John McCall return llvm::Constant::getNullValue(ConvertType(Ty)); 653a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson} 6544f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 6557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Visitor Methods 6577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitExpr(Expr *E) { 660488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGF.ErrorUnsupported(E, "scalar expression"); 6617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getType()->isVoidType()) 6627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 66303e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 6647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 6657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 666d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanValue *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 66737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Vector Mask Case 66837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 2 || 6693f4cb120fe574f7b80864f52a1999502a4f3a83dRafael Espindola (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { 67077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *LHS = CGF.EmitScalarExpr(E->getExpr(0)); 67177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *RHS = CGF.EmitScalarExpr(E->getExpr(1)); 67277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Mask; 67337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 67437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType()); 67537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman unsigned LHSElts = LTy->getNumElements(); 67637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 67737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 3) { 67837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = CGF.EmitScalarExpr(E->getExpr(2)); 67937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 68037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Shuffle LHS & RHS into one input vector. 68137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> concat; 68237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0; i != LHSElts; ++i) { 68377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i)); 68477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i+1)); 68537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 68637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 68737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* CV = llvm::ConstantVector::get(concat.begin(), concat.size()); 68837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); 68937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHSElts *= 2; 69037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } else { 69137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = RHS; 69237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 69337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 69437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType()); 69537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant* EltMask; 69637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 69737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Treat vec3 like vec4. 69837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) 69937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 70037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+2))-1); 70137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else if ((LHSElts == 3) && (E->getNumSubExprs() == 2)) 70237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 70337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+1))-1); 70437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else 70537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 70637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts))-1); 70737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 70837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Mask off the high bits of each shuffle index. 70937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant *, 32> MaskV; 71037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) 71137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MaskV.push_back(EltMask); 71237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 71337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* MaskBits = llvm::ConstantVector::get(MaskV.begin(), MaskV.size()); 71437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); 71537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 71637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = undef 71737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // mask = mask & maskbits 71837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // for each elt 71937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // n = extract mask i 72037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // x = extract val n 72137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = insert newv, x, i 72237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(), 72337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MTy->getNumElements()); 72437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* NewV = llvm::UndefValue::get(RTy); 72537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) { 72677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Indx = llvm::ConstantInt::get(CGF.Int32Ty, i); 72737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateExtractElement(Mask, Indx, "shuf_idx"); 72877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext"); 72937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 73037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 73137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { 73237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *cmpIndx, *newIndx; 73377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner cmpIndx = Builder.CreateICmpUGT(Indx, 73477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(CGF.Int32Ty, 3), 73537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "cmp_shuf_idx"); 73677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner newIndx = Builder.CreateSub(Indx, llvm::ConstantInt::get(CGF.Int32Ty,1), 73737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "shuf_idx_adj"); 73837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx"); 73937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 74037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt"); 74137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman NewV = Builder.CreateInsertElement(NewV, VExt, Indx, "shuf_ins"); 74237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 74337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman return NewV; 744d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 74537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 746d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 747d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 74837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 74937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 75037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> indices; 75137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 75237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant *C = cast<llvm::Constant>(CGF.EmitScalarExpr(E->getExpr(i))); 75337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *VTy = cast<llvm::VectorType>(V1->getType()); 75437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (VTy->getNumElements() == 3) { 75537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C)) { 75637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman uint64_t cVal = CI->getZExtValue(); 75737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (cVal > 3) { 75837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman C = llvm::ConstantInt::get(C->getType(), cVal-1); 75937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 76037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 76137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 76237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman indices.push_back(C); 76337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 76437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 7654a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson Value* SV = llvm::ConstantVector::get(indices.begin(), indices.size()); 766d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 767d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 76828665272c36cccb1014a6ea1217354b0519e2b59Eli FriedmanValue *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) { 76928665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 77028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 77128665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->isArrow()) 77228665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman CGF.EmitScalarExpr(E->getBase()); 77328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman else 77428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman EmitLValue(E->getBase()); 77528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 77628665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 77778ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel 77878ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // Emit debug info for aggregate now, if it was delayed to reduce 77978ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // debug info size. 78078ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel CGDebugInfo *DI = CGF.getDebugInfo(); 78178ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (DI && CGF.CGM.getCodeGenOpts().LimitDebugInfo) { 78278ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel QualType PQTy = E->getBase()->IgnoreParenImpCasts()->getType(); 78378ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (const PointerType * PTy = dyn_cast<PointerType>(PQTy)) 78449c8465f14fc3b2e1a32c7016ad3fb4e2cf8d466Devang Patel if (FieldDecl *M = dyn_cast<FieldDecl>(E->getMemberDecl())) 78578ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel DI->getOrCreateRecordType(PTy->getPointeeType(), 78678ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel M->getParent()->getLocation()); 7877fa8ab2e77f5703d0adf14e4d98f1edc1e66505dDevang Patel } 78828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return EmitLoadOfLValue(E); 78928665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman} 790d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 7917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 7927f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 7937f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 7947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Emit subscript expressions in rvalue context's. For most cases, this just 7957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // loads the lvalue formed by the subscript expr. However, we have to be 7967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // careful, because the base of a vector subscript is occasionally an rvalue, 7977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // so we can't get it as an lvalue. 7987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (!E->getBase()->getType()->isVectorType()) 7997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 800db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 8017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the vector case. The base must be a vector, the index must be an 8027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // integer value. 8037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Base = Visit(E->getBase()); 8047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Idx = Visit(E->getIdx()); 805daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman bool IdxSigned = E->getIdx()->getType()->isSignedIntegerType(); 80677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast"); 8077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateExtractElement(Base, Idx, "vecext"); 8087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 8097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 8100533b3020ca39898751d4200feed776861dcd1ceNate Begemanstatic llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, 8110533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned Off, const llvm::Type *I32Ty) { 8120533b3020ca39898751d4200feed776861dcd1ceNate Begeman int MV = SVI->getMaskValue(Idx); 8130533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (MV == -1) 8140533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::UndefValue::get(I32Ty); 8150533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::ConstantInt::get(I32Ty, Off+MV); 8160533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 8170533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8180533b3020ca39898751d4200feed776861dcd1ceNate BegemanValue *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { 8190533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool Ignore = TestAndClearIgnoreResultAssign(); 8200533b3020ca39898751d4200feed776861dcd1ceNate Begeman (void)Ignore; 8210533b3020ca39898751d4200feed776861dcd1ceNate Begeman assert (Ignore == false && "init list ignored"); 8220533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned NumInitElements = E->getNumInits(); 8230533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8240533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (E->hadArrayRangeDesignator()) 8250533b3020ca39898751d4200feed776861dcd1ceNate Begeman CGF.ErrorUnsupported(E, "GNU array range designator extension"); 8260533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8270533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VType = 8280533b3020ca39898751d4200feed776861dcd1ceNate Begeman dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 8290533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8300533b3020ca39898751d4200feed776861dcd1ceNate Begeman // We have a scalar in braces. Just use the first element. 8310533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VType) 8320533b3020ca39898751d4200feed776861dcd1ceNate Begeman return Visit(E->getInit(0)); 8330533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8340533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned ResElts = VType->getNumElements(); 8350533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8360533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Loop over initializers collecting the Value for each, and remembering 8370533b3020ca39898751d4200feed776861dcd1ceNate Begeman // whether the source was swizzle (ExtVectorElementExpr). This will allow 8380533b3020ca39898751d4200feed776861dcd1ceNate Begeman // us to fold the shuffle for the swizzle into the shuffle for the vector 8390533b3020ca39898751d4200feed776861dcd1ceNate Begeman // initializer, since LLVM optimizers generally do not want to touch 8400533b3020ca39898751d4200feed776861dcd1ceNate Begeman // shuffles. 8410533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned CurIdx = 0; 8420533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool VIsUndefShuffle = false; 8430533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *V = llvm::UndefValue::get(VType); 8440533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned i = 0; i != NumInitElements; ++i) { 8450533b3020ca39898751d4200feed776861dcd1ceNate Begeman Expr *IE = E->getInit(i); 8460533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Init = Visit(IE); 8470533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 8480533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8490533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType()); 8500533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8510533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Handle scalar elements. If the scalar initializer is actually one 8520533b3020ca39898751d4200feed776861dcd1ceNate Begeman // element of a different vector of the same width, use shuffle instead of 8530533b3020ca39898751d4200feed776861dcd1ceNate Begeman // extract+insert. 8540533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VVT) { 8550533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 8560533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init); 8570533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8580533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (EI->getVectorOperandType()->getNumElements() == ResElts) { 8590533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand()); 8600533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *LHS = 0, *RHS = 0; 8610533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) { 8620533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undef -> shuffle (src, undef) 8630533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(C); 8640533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 1; j != ResElts; ++j) 86577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8660533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8670533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = EI->getVectorOperand(); 8680533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = V; 8690533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = true; 8700533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else if (VIsUndefShuffle) { 8710533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undefshuffle && size match -> shuffle (v, src) 8720533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V); 8730533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 87477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty)); 87577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 8760533b3020ca39898751d4200feed776861dcd1ceNate Begeman ResElts + C->getZExtValue())); 8770533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + 1; j != ResElts; ++j) 87877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8790533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8800533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 8810533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = EI->getVectorOperand(); 8820533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8830533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8840533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!Args.empty()) { 8850533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 8860533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(LHS, RHS, Mask); 8870533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8880533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8890533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8900533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8910533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 89277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 8930533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 8940533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8950533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8960533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8970533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8980533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8990533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned InitElts = VVT->getNumElements(); 9000533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9010533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's 9020533b3020ca39898751d4200feed776861dcd1ceNate Begeman // input is the same width as the vector being constructed, generate an 9030533b3020ca39898751d4200feed776861dcd1ceNate Begeman // optimized shuffle of the swizzle input into the result. 904a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman unsigned Offset = (CurIdx == 0) ? 0 : ResElts; 9050533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 9060533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init); 9070533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *SVOp = SVI->getOperand(0); 9080533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType()); 9090533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9100533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (OpTy->getNumElements() == ResElts) { 9110533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) { 9120533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the current vector initializer is a shuffle with undef, merge 9130533b3020ca39898751d4200feed776861dcd1ceNate Begeman // this shuffle directly into it. 9140533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) { 9150533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0, 91677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner CGF.Int32Ty)); 9170533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else { 91877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 9190533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9200533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9210533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0, je = InitElts; j != je; ++j) 92277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty)); 9230533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 92477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9250533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9260533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) 9270533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 9280533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9290533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = SVOp; 9300533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9310533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9320533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9330533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Extend init to result vector length, and then shuffle its contribution 9340533b3020ca39898751d4200feed776861dcd1ceNate Begeman // to the vector initializer into V. 9350533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (Args.empty()) { 9360533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 93777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 9380533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = InitElts; j != ResElts; ++j) 93977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9400533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 9410533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), 942a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman Mask, "vext"); 9430533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9440533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.clear(); 9450533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 94677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 9470533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 94877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j+Offset)); 9490533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 95077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9510533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9520533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9530533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If V is undef, make sure it ends up on the RHS of the shuffle to aid 9540533b3020ca39898751d4200feed776861dcd1ceNate Begeman // merging subsequent shuffles into this one. 9550533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) 9560533b3020ca39898751d4200feed776861dcd1ceNate Begeman std::swap(V, Init); 9570533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 9580533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit"); 9590533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = isa<llvm::UndefValue>(Init); 9600533b3020ca39898751d4200feed776861dcd1ceNate Begeman CurIdx += InitElts; 9610533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9620533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9630533b3020ca39898751d4200feed776861dcd1ceNate Begeman // FIXME: evaluate codegen vs. shuffling against constant null vector. 9640533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers. 9650533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::Type *EltTy = VType->getElementType(); 9660533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9670533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers 9680533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { 96977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 9700533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *Init = llvm::Constant::getNullValue(EltTy); 9710533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 9720533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9730533b3020ca39898751d4200feed776861dcd1ceNate Begeman return V; 9740533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 9750533b3020ca39898751d4200feed776861dcd1ceNate Begeman 976a3697c9c155bda93fd2802f37084b620f4738822Anders Carlssonstatic bool ShouldNullCheckClassCastValue(const CastExpr *CE) { 977a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const Expr *E = CE->getSubExpr(); 97823cba801e11b03929c44f8cf54578305963a3476John McCall 9792de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CE->getCastKind() == CK_UncheckedDerivedToBase) 98023cba801e11b03929c44f8cf54578305963a3476John McCall return false; 981a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 982a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (isa<CXXThisExpr>(E)) { 983a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // We always assume that 'this' is never null. 984a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 985a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 986a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 987a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) { 988906082edf2aea1c6de2926f93a8d7121e49d2a54Sebastian Redl // And that glvalue casts are never null. 9895baba9d98364a3525d6afa15a04cdad82fd6dd30John McCall if (ICE->getValueKind() != VK_RValue) 990a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 991a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 992a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 993a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return true; 994a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson} 995a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 996504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 997504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// have to handle a more broad range of conversions than explicit casts, as they 998504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// handle things like function to ptr-to-function decay etc. 999d888962cff03b543fbe9ac6051ec6addf5b993b4Eli FriedmanValue *ScalarExprEmitter::EmitCastExpr(CastExpr *CE) { 1000d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Expr *E = CE->getSubExpr(); 1001592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson QualType DestTy = CE->getType(); 10022de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CastKind Kind = CE->getCastKind(); 1003592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson 1004504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson if (!DestTy->isVoidType()) 1005504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson TestAndClearIgnoreResultAssign(); 1006db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10078c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // Since almost all cast kinds apply to scalars, this switch doesn't have 10088c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // a default case, so the compiler will warn on a missing case. The cases 10098c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // are in the same order as in the CastKind enum. 1010504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson switch (Kind) { 1011daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!"); 1012daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 10132de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_LValueBitCast: 10142de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ObjCObjectLValueCast: { 1015e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor Value *V = EmitLValue(E).getAddress(); 1016e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor V = Builder.CreateBitCast(V, 1017e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor ConvertType(CGF.getContext().getPointerType(DestTy))); 10189f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), DestTy); 1019e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor } 1020e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor 10212de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_AnyPointerToObjCPointerCast: 10222de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_AnyPointerToBlockPointerCast: 10232de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BitCast: { 1024cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 1025cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson return Builder.CreateBitCast(Src, ConvertType(DestTy)); 1026cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson } 10272de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NoOp: 10282de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UserDefinedConversion: 1029ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Visit(const_cast<Expr*>(E)); 1030db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10312de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerived: { 1032a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const CXXRecordDecl *DerivedClassDecl = 1033a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson DestTy->getCXXRecordDeclForPointerType(); 1034a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 1035a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl, 1036f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 1037a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson ShouldNullCheckClassCastValue(CE)); 1038a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 10392de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UncheckedDerivedToBase: 10402de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBase: { 1041191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson const RecordType *DerivedClassTy = 1042191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson E->getType()->getAs<PointerType>()->getPointeeType()->getAs<RecordType>(); 1043191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson CXXRecordDecl *DerivedClassDecl = 1044191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1045191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 104634a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, 1047f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 104834a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson ShouldNullCheckClassCastValue(CE)); 1049191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson } 10502de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_Dynamic: { 10518c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman Value *V = Visit(const_cast<Expr*>(E)); 10528c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE); 10538c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman return CGF.EmitDynamicCast(V, DCE); 10548c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman } 1055d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 10562de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ArrayToPointerDecay: { 1057ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(E->getType()->isArrayType() && 1058ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Array to pointer decay must have array source type!"); 1059ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1060ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *V = EmitLValue(E).getAddress(); // Bitfields can't be arrays. 1061ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1062ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Note that VLA pointers are always decayed, so we don't need to do 1063ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // anything here. 1064ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman if (!E->getType()->isVariableArrayType()) { 1065ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 1066ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 1067ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman ->getElementType()) && 1068ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Expected pointer to array"); 1069ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman V = Builder.CreateStructGEP(V, 0, "arraydecay"); 1070ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1071ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1072ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return V; 1073ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 10742de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FunctionToPointerDecay: 1075ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return EmitLValue(E).getAddress(); 1076ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1077404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall case CK_NullToPointer: 1078404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall if (MustVisitNullValue(E)) 1079404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall (void) Visit(E); 1080404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 1081404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall return llvm::ConstantPointerNull::get( 1082404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall cast<llvm::PointerType>(ConvertType(DestTy))); 1083404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 10842de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NullToMemberPointer: { 1085404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall if (MustVisitNullValue(E)) 1086d608cdb7c044365cf4e8764ade1e11e99c176078John McCall (void) Visit(E); 1087d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 10880bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>(); 10890bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 10900bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 1091191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 10922de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerivedMemberPointer: 10932de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBaseMemberPointer: { 1094d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *Src = Visit(E); 1095d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 1096d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // Note that the AST doesn't distinguish between checked and 1097d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // unchecked member pointer conversions, so we always have to 1098d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // implement checked conversions here. This is inefficient when 1099d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // actual control flow may be required in order to perform the 1100d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // check, which it is for data member pointers (but not member 1101d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // function pointers on Itanium and ARM). 11020bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src); 1103d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 11040bab0cdab751248ca389a5592bcb70eac5d39260John McCall 11052bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingRealToComplex: 11062bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingComplexCast: 11072bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralRealToComplex: 11082bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralComplexCast: 1109f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToFloatingComplex: 1110f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToIntegralComplex: 11112de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ConstructorConversion: 111261ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall case CK_ToUnion: 111361ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall llvm_unreachable("scalar cast to non-scalar value"); 11148c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman break; 1115f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall 1116f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall case CK_GetObjCProperty: { 1117f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)); 1118da29e091650dc011df5209578d7c049549e5e34bDouglas Gregor assert(E->isGLValue() && E->getObjectKind() == OK_ObjCProperty && 1119f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall "CK_GetObjCProperty for non-lvalue or non-ObjCProperty"); 1120f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall RValue RV = CGF.EmitLoadOfLValue(CGF.EmitLValue(E), E->getType()); 1121f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall return RV.getScalarVal(); 1122f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall } 11230ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall 11240ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall case CK_LValueToRValue: 11250ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)); 1126f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(E->isGLValue() && "lvalue-to-rvalue applied to r-value!"); 11270ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall return Visit(const_cast<Expr*>(E)); 11288c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman 11292de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToPointer: { 11307f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 113189f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 113282debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // First, convert to the correct width so that we control the kind of 113382debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // extension. 113477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 113582debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson bool InputSigned = E->getType()->isSignedIntegerType(); 113682debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson llvm::Value* IntResult = 113782debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 113889f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 113982debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy)); 11407f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 11412de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_PointerToIntegral: { 11427f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 114389f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 114489f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar // Handle conversion to bool correctly. 114589f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar if (DestTy->isBooleanType()) 1146db50547fd526329d00fa1fee4e7ac90f2624c6e0Daniel Dunbar return EmitScalarConversion(Src, E->getType(), DestTy); 114789f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 11487f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson return Builder.CreatePtrToInt(Src, ConvertType(DestTy)); 11497f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 11502de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ToVoid: { 11512a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E); 1152ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return 0; 1153ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 11542de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_VectorSplat: { 1155ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman const llvm::Type *DstTy = ConvertType(DestTy); 1156ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *Elt = Visit(const_cast<Expr*>(E)); 1157ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1158ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Insert the element in element zero of an undef vector 1159ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *UnV = llvm::UndefValue::get(DstTy); 116077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 1161ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 1162ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1163ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Splat the element across to all elements 1164ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::SmallVector<llvm::Constant*, 16> Args; 1165ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 1166daa8e4e888758d55a7a759dd4a91b83921cef222John McCall llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Int32Ty, 0); 1167ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman for (unsigned i = 0; i < NumElements; i++) 1168daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Args.push_back(Zero); 1169ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1170ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 1171ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 1172ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Yay; 1173ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1174daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 11752de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralCast: 11762de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToFloating: 11772de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingToIntegral: 11782de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingCast: 1179d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return EmitScalarConversion(Visit(E), E->getType(), DestTy); 1180ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1181daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_IntegralToBoolean: 1182daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitIntToBoolConversion(Visit(E)); 1183daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_PointerToBoolean: 1184daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitPointerToBoolConversion(Visit(E)); 1185daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_FloatingToBoolean: 1186daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitFloatToBoolConversion(Visit(E)); 11872de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_MemberPointerToBoolean: { 11880bab0cdab751248ca389a5592bcb70eac5d39260John McCall llvm::Value *MemPtr = Visit(E); 11890bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>(); 11900bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT); 1191e9776247577715ad3a19461769a3488a445a8cbdAnders Carlsson } 1192f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1193f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToReal: 1194f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToReal: 1195b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(E, false, true).first; 1196f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1197f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToBoolean: 1198f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToBoolean: { 1199b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall CodeGenFunction::ComplexPairTy V = CGF.EmitComplexExpr(E); 1200f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1201f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall // TODO: kill this function off, inline appropriate case here 1202f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall return EmitComplexToScalarConversion(V, E->getType(), DestTy); 1203f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall } 1204f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 12050bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 120610b00cfe6422906b223724048b9b2123968d3baaChris Lattner 120761ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall llvm_unreachable("unknown scalar cast"); 120819a1d7c646729eb858b15583e647262a22de3637Chris Lattner return 0; 12097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12113379320c10001d7e1ee5d7e7142c417f797cfe82Chris LattnerValue *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 1212150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::StmtExprEvaluation eval(CGF); 1213150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall return CGF.EmitCompoundStmt(*E->getSubStmt(), !E->getType()->isVoidType()) 1214150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall .getScalarVal(); 12153379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner} 12163379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 1217a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike StumpValue *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 1218f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian llvm::Value *V = CGF.GetAddrOfBlockDecl(E); 1219f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian if (E->getType().isObjCGCWeak()) 1220f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian return CGF.CGM.getObjCRuntime().EmitObjCWeakRead(CGF, V); 1221469a20de757ff872c90ff6b1134f6346909ff652Fariborz Jahanian return CGF.EmitLoadOfScalar(V, false, 0, E->getType()); 12224e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump} 12233379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 12247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Unary Operators 12267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12288c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *ScalarExprEmitter:: 1229683564a7a93c952f1fbe573b55c542418d29d859Anton YartsevEmitAddConsiderOverflowBehavior(const UnaryOperator *E, 1230683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *InVal, 1231683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::Value *NextVal, bool IsInc) { 1232683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1233683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Undefined: 1234683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return Builder.CreateNSWAdd(InVal, NextVal, IsInc ? "inc" : "dec"); 1235683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev break; 1236683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Defined: 1237683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return Builder.CreateAdd(InVal, NextVal, IsInc ? "inc" : "dec"); 1238683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev break; 1239683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev case LangOptions::SOB_Trapping: 1240683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOpInfo BinOp; 1241683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.LHS = InVal; 1242683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.RHS = NextVal; 1243683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.Ty = E->getType(); 1244683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.Opcode = BO_Add; 1245683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev BinOp.E = E; 1246683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return EmitOverflowCheckedBinOp(BinOp); 1247683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev break; 1248683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } 1249683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev assert(false && "Unknown SignedOverflowBehaviorTy"); 1250683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev return 0; 1251683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev} 1252683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 1253683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsevllvm::Value *ScalarExprEmitter:: 12548c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 12558c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 12568c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12578c11a65c18ae607b7073e1e451264492d2297726Chris Lattner QualType ValTy = E->getSubExpr()->getType(); 12588c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *InVal = EmitLoadOfLValue(LV, ValTy); 12598c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12608c11a65c18ae607b7073e1e451264492d2297726Chris Lattner int AmountVal = isInc ? 1 : -1; 12618c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12628c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (ValTy->isPointerType() && 12638c11a65c18ae607b7073e1e451264492d2297726Chris Lattner ValTy->getAs<PointerType>()->isVariableArrayType()) { 12648c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // The amount of the addition/subtraction needs to account for the VLA size 12658c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.ErrorUnsupported(E, "VLA pointer inc/dec"); 12668c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 12678c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12688c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *NextVal; 12698c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (const llvm::PointerType *PT = 12708c11a65c18ae607b7073e1e451264492d2297726Chris Lattner dyn_cast<llvm::PointerType>(InVal->getType())) { 127177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Constant *Inc = llvm::ConstantInt::get(CGF.Int32Ty, AmountVal); 12728c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (!isa<llvm::FunctionType>(PT->getElementType())) { 12738c11a65c18ae607b7073e1e451264492d2297726Chris Lattner QualType PTEE = ValTy->getPointeeType(); 12748c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (const ObjCObjectType *OIT = PTEE->getAs<ObjCObjectType>()) { 12758c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Handle interface types, which are not represented with a concrete 12768c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // type. 1277fe71008c2764768f25478b16c1802755189ed7c9Ken Dyck CharUnits size = CGF.getContext().getTypeSizeInChars(OIT); 12788c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (!isInc) 12798c11a65c18ae607b7073e1e451264492d2297726Chris Lattner size = -size; 1280fe71008c2764768f25478b16c1802755189ed7c9Ken Dyck Inc = llvm::ConstantInt::get(Inc->getType(), size.getQuantity()); 12818c11a65c18ae607b7073e1e451264492d2297726Chris Lattner const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 12828c11a65c18ae607b7073e1e451264492d2297726Chris Lattner InVal = Builder.CreateBitCast(InVal, i8Ty); 12838c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateGEP(InVal, Inc, "add.ptr"); 12848c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *lhs = LV.getAddress(); 12858c11a65c18ae607b7073e1e451264492d2297726Chris Lattner lhs = Builder.CreateBitCast(lhs, llvm::PointerType::getUnqual(i8Ty)); 12869f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar LV = CGF.MakeAddrLValue(lhs, ValTy); 12878c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else 12888c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateInBoundsGEP(InVal, Inc, "ptrincdec"); 12898c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 12908c11a65c18ae607b7073e1e451264492d2297726Chris Lattner const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 12918c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateBitCast(InVal, i8Ty, "tmp"); 12928c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateGEP(NextVal, Inc, "ptrincdec"); 12938c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateBitCast(NextVal, InVal->getType()); 12948c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 12958c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else if (InVal->getType()->isIntegerTy(1) && isInc) { 12968c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool++ is an interesting case, due to promotion rules, we get: 12978c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool++ -> Bool = Bool+1 -> Bool = (int)Bool+1 -> 12988c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool = ((int)Bool+1) != 0 12998c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // An interesting aspect of this is that increment is always true. 13008c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Decrement does not have this property. 13018c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantInt::getTrue(VMContext); 1302683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } else if (ValTy->isVectorType()) { 1303683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev if (ValTy->hasIntegerRepresentation()) { 1304683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal); 1305683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 1306683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev NextVal = ValTy->hasSignedIntegerRepresentation() ? 1307683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev EmitAddConsiderOverflowBehavior(E, InVal, NextVal, isInc) : 1308683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1309683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } else { 1310683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev NextVal = Builder.CreateFAdd( 1311683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev InVal, 1312683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev llvm::ConstantFP::get(InVal->getType(), AmountVal), 1313683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev isInc ? "inc" : "dec"); 1314683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev } 13158c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else if (isa<llvm::IntegerType>(InVal->getType())) { 13168c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal); 1317683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev 1318683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev NextVal = ValTy->isSignedIntegerType() ? 1319683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev EmitAddConsiderOverflowBehavior(E, InVal, NextVal, isInc) : 1320683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev // Unsigned integer inc is always two's complement. 1321683564a7a93c952f1fbe573b55c542418d29d859Anton Yartsev Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 13228c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 13238c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Add the inc/dec to the real part. 13248c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (InVal->getType()->isFloatTy()) 13258c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = 13268c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::ConstantFP::get(VMContext, 13278c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat(static_cast<float>(AmountVal))); 13288c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else if (InVal->getType()->isDoubleTy()) 13298c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = 13308c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::ConstantFP::get(VMContext, 13318c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat(static_cast<double>(AmountVal))); 13328c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else { 13338c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat F(static_cast<float>(AmountVal)); 13348c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool ignored; 13358c11a65c18ae607b7073e1e451264492d2297726Chris Lattner F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 13368c11a65c18ae607b7073e1e451264492d2297726Chris Lattner &ignored); 13378c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantFP::get(VMContext, F); 13388c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 13398c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateFAdd(InVal, NextVal, isInc ? "inc" : "dec"); 13408c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 13418c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13428c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Store the updated result through the lvalue. 13438c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (LV.isBitField()) 13448c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.EmitStoreThroughBitfieldLValue(RValue::get(NextVal), LV, ValTy, &NextVal); 13458c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else 13468c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.EmitStoreThroughLValue(RValue::get(NextVal), LV, ValTy); 13478c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13488c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // If this is a postinc, return the value read from memory, otherwise use the 13498c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // updated value. 13508c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return isPre ? NextVal : InVal; 13518c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 13528c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13538c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13548c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 13567f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 13579a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Emit unary minus with EmitSub so we handle overflow cases etc. 13589a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOpInfo BinOp; 13594ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.RHS = Visit(E->getSubExpr()); 13604ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner 13614ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner if (BinOp.RHS->getType()->isFPOrFPVectorTy()) 13624ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType()); 13634ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner else 13644ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType()); 13659a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.Ty = E->getType(); 13662de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall BinOp.Opcode = BO_Sub; 13679a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.E = E; 13689a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner return EmitSub(BinOp); 13697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 13727f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 13737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 13747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNot(Op, "neg"); 13757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 13787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Compare operand to zero. 13797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 1380db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 13817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Invert value. 13827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // TODO: Could dynamically modify easy computations here. For example, if 13837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // the operand is an icmp ne, turn into icmp eq. 13847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BoolVal = Builder.CreateNot(BoolVal, "lnot"); 1385db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 13869f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson // ZExt result to the expr type. 13879f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext"); 13887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13900027d2bb24db629a33a71d04a5fb90a14c15a680Eli FriedmanValue *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) { 13910027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Try folding the offsetof to a constant. 13920027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr::EvalResult EvalResult; 13930027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (E->Evaluate(EvalResult, CGF.getContext())) 13940027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman return llvm::ConstantInt::get(VMContext, EvalResult.Val.getInt()); 13950027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13960027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Loop over the components of the offsetof to compute the value. 13970027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned n = E->getNumComponents(); 13980027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const llvm::Type* ResultType = ConvertType(E->getType()); 13990027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Result = llvm::Constant::getNullValue(ResultType); 14000027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman QualType CurrentType = E->getTypeSourceInfo()->getType(); 14010027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (unsigned i = 0; i != n; ++i) { 14020027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman OffsetOfExpr::OffsetOfNode ON = E->getComponent(i); 140316fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman llvm::Value *Offset = 0; 14040027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman switch (ON.getKind()) { 14050027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Array: { 14060027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index 14070027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex()); 14080027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr); 14090027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman bool IdxSigned = IdxExpr->getType()->isSignedIntegerType(); 14100027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv"); 14110027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14120027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type 14130027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = 14140027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getAsArrayType(CurrentType)->getElementType(); 14150027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14160027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the element size 14170027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType, 14180027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity()); 14190027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14200027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Multiply out to compute the result 14210027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = Builder.CreateMul(Idx, ElemSize); 14220027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14230027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14240027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14250027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Field: { 14260027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldDecl *MemberDecl = ON.getField(); 14270027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 14280027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 14290027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14300027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index of the field in its parent. 14310027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned i = 0; 14320027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // FIXME: It would be nice if we didn't have to loop here! 14330027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (RecordDecl::field_iterator Field = RD->field_begin(), 14340027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldEnd = RD->field_end(); 14350027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Field != FieldEnd; (void)++Field, ++i) { 14360027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (*Field == MemberDecl) 14370027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14380027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14390027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman assert(i < RL.getFieldCount() && "offsetof field in wrong type"); 14400027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14410027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the field 14420027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman int64_t OffsetInt = RL.getFieldOffset(i) / 14430027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 14440027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 14450027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14460027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 14470027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = MemberDecl->getType(); 14480027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14490027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 145016fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 14510027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Identifier: 14526d4e44b462fe9e870a40358522379400ccc6e3c2Eli Friedman llvm_unreachable("dependent __builtin_offsetof"); 145316fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 14540027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Base: { 14550027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (ON.getBase()->isVirtual()) { 14560027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.ErrorUnsupported(E, "virtual base in offsetof"); 14570027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman continue; 14580027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14590027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14600027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 14610027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 14620027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14630027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 14640027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = ON.getBase()->getType(); 14650027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14660027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the base. 14670027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const RecordType *BaseRT = CurrentType->getAs<RecordType>(); 14680027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl()); 1469a14f5979572aa25c03d24750ee4724d2031d4edeAnders Carlsson int64_t OffsetInt = RL.getBaseClassOffsetInBits(BaseRD) / 14700027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 14710027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 14720027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14730027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14740027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14750027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Result = Builder.CreateAdd(Result, Offset); 14760027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14770027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman return Result; 14788ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor} 14798ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 14800518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// VisitSizeOfAlignOfExpr - Return the size or alignment of the type of 14810518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// argument of the sizeof expression as an integer. 14820518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlValue * 14830518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) { 14840518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl QualType TypeToSize = E->getTypeOfArgument(); 1485f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isSizeOf()) { 1486db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (const VariableArrayType *VAT = 1487f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.getContext().getAsVariableArrayType(TypeToSize)) { 1488f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isArgumentType()) { 1489f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // sizeof(type) - make sure to emit the VLA size. 1490f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.EmitVLASize(TypeToSize); 14918f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman } else { 14928f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // C99 6.5.3.4p2: If the argument is an expression of type 14938f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // VLA, it is evaluated. 14942a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E->getArgumentExpr()); 1495f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman } 1496db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 149796f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson return CGF.GetVLASize(VAT); 1498b50525ba0e996bc072cdb76152fcfe0bc64bb72aAnders Carlsson } 14995d46315ca3cbbfe0d0f5f65520b618fb05dd4446Anders Carlsson } 1500f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman 1501db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If this isn't sizeof(vla), the result must be constant; use the constant 1502db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // folding logic so we don't have to duplicate it here. 1503f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman Expr::EvalResult Result; 1504f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman E->Evaluate(Result, CGF.getContext()); 15054a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 15067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 15077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 150846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 150946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 1510b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (Op->getType()->isAnyComplexType()) { 1511b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If it's an l-value, load through the appropriate subobject l-value. 1512b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Note that we have to ask E because Op might be an l-value that 1513b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // this won't work for, e.g. an Obj-C property. 15147eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (E->isGLValue()) 1515b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitLoadOfLValue(CGF.EmitLValue(E), E->getType()) 1516b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall .getScalarVal(); 1517b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1518b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Otherwise, calculate and project. 1519b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(Op, false, true).first; 1520b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall } 1521b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 152246f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return Visit(Op); 152346f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 1524b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 152546f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 152646f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 1527b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (Op->getType()->isAnyComplexType()) { 1528b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If it's an l-value, load through the appropriate subobject l-value. 1529b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Note that we have to ask E because Op might be an l-value that 1530b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // this won't work for, e.g. an Obj-C property. 15317eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (Op->isGLValue()) 1532b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitLoadOfLValue(CGF.EmitLValue(E), E->getType()) 1533b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall .getScalarVal(); 1534b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1535b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Otherwise, calculate and project. 1536b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(Op, true, false).second; 1537b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall } 1538db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 15397f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __imag on a scalar returns zero. Emit the subexpr to ensure side 15407f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // effects are evaluated, but not the actual value. 1541b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall CGF.EmitScalarExpr(Op, true); 1542c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson return llvm::Constant::getNullValue(ConvertType(E->getType())); 154346f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 154446f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 15457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 15467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Binary Operators 15477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 15487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerBinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 15507f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 15517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BinOpInfo Result; 15527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.LHS = Visit(E->getLHS()); 15537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.RHS = Visit(E->getRHS()); 15541f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Result.Ty = E->getType(); 15559a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner Result.Opcode = E->getOpcode(); 15567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.E = E; 15577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Result; 15587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 15597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15606a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue ScalarExprEmitter::EmitCompoundAssignLValue( 15616a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E, 15626a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), 1563d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result) { 156454d76db0aa7107597cac0b80d8e138a37e6d1de9Benjamin Kramer QualType LHSTy = E->getLHS()->getType(); 15651f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo OpInfo; 15666a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1567ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman if (E->getComputationResultType()->isAnyComplexType()) { 1568db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // This needs to go through the complex expression emitter, but it's a tad 1569db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // complicated to do that... I'm leaving it out for now. (Note that we do 1570db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // actually need the imaginary part of the RHS for multiplication and 1571db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // division.) 1572ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman CGF.ErrorUnsupported(E, "complex compound assignment"); 1573d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = llvm::UndefValue::get(CGF.ConvertType(E->getType())); 15746a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LValue(); 15751f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 15766a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1577cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // Emit the RHS first. __block variables need to have the rhs evaluated 1578cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // first, plus this should improve codegen a little. 1579cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.RHS = Visit(E->getRHS()); 1580cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.Ty = E->getComputationResultType(); 15819a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OpInfo.Opcode = E->getOpcode(); 1582cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.E = E; 1583ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // Load/convert the LHS. 1584b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHSLV = EmitCheckedLValue(E->getLHS()); 1585ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy); 1586ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 1587ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman E->getComputationLHSType()); 15886a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 15891f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Expand the binary operator. 1590d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = (this->*Func)(OpInfo); 15916a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 15928c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Convert the result back to the LHS type. 1593ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 15946a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1595db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Store the result value into the LHS lvalue. Bit-fields are handled 1596db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // specially because the result is altered by the store, i.e., [C99 6.5.16p1] 1597db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // 'An assignment expression has the value of the left operand after the 1598db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // assignment...'. 1599d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHSLV.isBitField()) 1600d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy, 1601d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar &Result); 1602d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 1603ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy); 1604d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 16056a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LHSLV; 16066a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 16076a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 16086a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorValue *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 16096a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 16106a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor bool Ignore = TestAndClearIgnoreResultAssign(); 1611d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *RHS; 1612d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar LValue LHS = EmitCompoundAssignLValue(E, Func, RHS); 1613d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1614d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 16157f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 16167f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 1617d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1618b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 1619b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!CGF.getContext().getLangOptions().CPlusPlus) 1620b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return RHS; 1621b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1622d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 1623119a1c6c4029d30cae7b31a2826aa0ff70d01668John McCall if (LHS.isPropertyRef()) 1624d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1625d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1626d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 1627d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 1628d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1629d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1630d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 1631d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return EmitLoadOfLValue(LHS, E->getType()); 16321f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner} 16331f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 16348023030f76d334355b73d9c675d3870858aaf4fdChris Lattnervoid ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck( 16358023030f76d334355b73d9c675d3870858aaf4fdChris Lattner const BinOpInfo &Ops, 16368023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero, bool isDiv) { 16378023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 16388023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *contBB = 16398023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.createBasicBlock(isDiv ? "div.cont" : "rem.cont", CGF.CurFn); 16408023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16418023030f76d334355b73d9c675d3870858aaf4fdChris Lattner const llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType()); 16428023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16438023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->hasSignedIntegerRepresentation()) { 16448023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *IntMin = 16458023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::ConstantInt::get(VMContext, 16468023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::APInt::getSignedMinValue(Ty->getBitWidth())); 16478023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL); 16488023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16498023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond1 = Builder.CreateICmpEQ(Ops.RHS, Zero); 16508023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *LHSCmp = Builder.CreateICmpEQ(Ops.LHS, IntMin); 16518023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *RHSCmp = Builder.CreateICmpEQ(Ops.RHS, NegOne); 16528023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond2 = Builder.CreateAnd(LHSCmp, RHSCmp, "and"); 16538023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCondBr(Builder.CreateOr(Cond1, Cond2, "or"), 16548023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 16558023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } else { 16568023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateICmpEQ(Ops.RHS, Zero), 16578023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 16588023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 16598023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 16608023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(contBB); 16618023030f76d334355b73d9c675d3870858aaf4fdChris Lattner} 16621f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 16637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 16648023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 16658023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 16668023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16678023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 16688023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true); 16698023030f76d334355b73d9c675d3870858aaf4fdChris Lattner else if (Ops.Ty->isRealFloatingType()) { 16708023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", 16718023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.CurFn); 16728023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *DivCont = CGF.createBasicBlock("div.cont", CGF.CurFn); 16738023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero), 16748023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, DivCont); 16758023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 16768023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(DivCont); 16778023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 16788023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 1679f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 16807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 1681f60946222721d9ba3c059563935c17b84703187aDouglas Gregor else if (Ops.Ty->hasUnsignedIntegerRepresentation()) 16827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 16837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 16847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 16857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 16867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 16887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Rem in C can't be a floating point type: C99 6.5.5p2. 16898023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 16908023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 16918023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16928023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 16938023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false); 16948023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 16958023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16961f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner if (Ops.Ty->isUnsignedIntegerType()) 16977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 16987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 16997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 17007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 17017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17022add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike StumpValue *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 17032add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned IID; 17042add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned OpID = 0; 17055d8b2cf9fd704f6ca5e33525803a65421c0b440eMike Stump 17069a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner switch (Ops.Opcode) { 17072de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 17082de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_AddAssign: 1709035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 1; 1710035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::sadd_with_overflow; 1711035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 17122de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 17132de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_SubAssign: 1714035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 2; 1715035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::ssub_with_overflow; 1716035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 17172de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 17182de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_MulAssign: 1719035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 3; 1720035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::smul_with_overflow; 1721035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1722035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump default: 1723035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump assert(false && "Unsupported operation for overflow detection"); 1724ab4eff620a9ce0ea62cdf29529a66c2c98d116f5Daniel Dunbar IID = 0; 1725035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump } 1726035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID <<= 1; 1727035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID |= 1; 1728035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump 17292add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 17302add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17312add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1); 17322add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17332add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 17342add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 17352add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 17362add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17372add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Branch in case of overflow. 17387f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::BasicBlock *initialBB = Builder.GetInsertBlock(); 173993a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 174093a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn); 17412add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17422add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateCondBr(overflow, overflowBB, continueBB); 17432add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 174493a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner // Handle overflow with llvm.trap. 17457f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall const std::string *handlerName = 17467f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall &CGF.getContext().getLangOptions().OverflowHandler; 17477f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall if (handlerName->empty()) { 17487f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall EmitOverflowBB(overflowBB); 17497f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(continueBB); 17507f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return result; 17517f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall } 17527f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17537f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // If an overflow handler is set, then we want to call it and then use its 17547f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // result, if it returns. 17557f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(overflowBB); 17567f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17577f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Get the overflow handler. 17587f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall const llvm::Type *Int8Ty = llvm::Type::getInt8Ty(VMContext); 17597f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall std::vector<const llvm::Type*> argTypes; 17607f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall argTypes.push_back(CGF.Int64Ty); argTypes.push_back(CGF.Int64Ty); 17617f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall argTypes.push_back(Int8Ty); argTypes.push_back(Int8Ty); 17627f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType *handlerTy = 17637f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType::get(CGF.Int64Ty, argTypes, true); 17647f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName); 17657f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17667f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Sign extend the args to 64-bit, so that we can use the same handler for 17677f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // all types of overflow. 17687f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty); 17697f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty); 17707f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17717f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Call the handler with the two arguments, the operation, and the size of 17727f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // the result. 17737f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handlerResult = Builder.CreateCall4(handler, lhs, rhs, 17747f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(OpID), 17757f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())); 17767f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17777f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Truncate the result back to the desired size. 17787f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall handlerResult = Builder.CreateTrunc(handlerResult, opTy); 17797f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.CreateBr(continueBB); 17807f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17812add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(continueBB); 17827f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::PHINode *phi = Builder.CreatePHI(opTy); 17837f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->reserveOperandSpace(2); 17847f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(result, initialBB); 17857f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(handlerResult, overflowBB); 17867f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17877f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return phi; 17882add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump} 17897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { 179158f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (!Ops.Ty->isAnyPointerType()) { 1792f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 1793a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1794a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1795a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "add"); 1796a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1797a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 1798a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1799a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1800a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1801a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1802a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1803f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 180487415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFAdd(Ops.LHS, Ops.RHS, "add"); 1805bf933a0cb628670490c15367b3f5ccb3193354a7Dan Gohman 18067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 18072add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 1808daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 18097f215c12af4c3e7f81b24102a676aabfdb4e1566Chris Lattner // Must have binary (not unary) expr here. Unary pointer decrement doesn't 18109a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 18119a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 18129a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 181314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (Ops.Ty->isPointerType() && 18146217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek Ops.Ty->getAs<PointerType>()->isVariableArrayType()) { 1815daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size 18169a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer addition"); 1817daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 18189a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 18198f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Value *Ptr, *Idx; 18208f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Expr *IdxExp; 18219a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const PointerType *PT = BinOp->getLHS()->getType()->getAs<PointerType>(); 1822db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump const ObjCObjectPointerType *OPT = 18239a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<ObjCObjectPointerType>(); 182414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (PT || OPT) { 18258f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.LHS; 18268f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.RHS; 18279a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getRHS(); 182814108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } else { // int + pointer 18299a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner PT = BinOp->getRHS()->getType()->getAs<PointerType>(); 18309a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OPT = BinOp->getRHS()->getType()->getAs<ObjCObjectPointerType>(); 183114108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff assert((PT || OPT) && "Invalid add expr"); 18328f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.RHS; 18338f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.LHS; 18349a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getLHS(); 18358f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 18368f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner 18378f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 18387cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 18398f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // Zero or sign extend the pointer value based on whether the index is 18408f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // signed or not. 184177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *IdxType = CGF.IntPtrTy; 18429619662a1d42e2008b865d3459c0677e149dad1bChris Lattner if (IdxExp->getType()->isSignedIntegerType()) 18438f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 18448f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner else 18458f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 18468f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 184714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType ElementType = PT ? PT->getPointeeType() : OPT->getPointeeType(); 1848db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1849c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = ElementType->getAs<ObjCObjectType>()) { 1850db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 18514a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1852199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext().getTypeSizeInChars(OIT).getQuantity()); 18532a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 18543c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 18552a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 18562a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 18572a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1858db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 18592a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1860db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Explicitly handle GNU void* and function pointer arithmetic extensions. The 1861db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // GNU void* casts amount to no-ops since our void* type is i8*, but this is 1862db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // future proof. 1863b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (ElementType->isVoidType() || ElementType->isFunctionType()) { 18643c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1865b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 18662a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 1867b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1868db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1869db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1870664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ptr, Idx, "add.ptr"); 18717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 18727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 18737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { 18742add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump if (!isa<llvm::PointerType>(Ops.LHS->getType())) { 1875f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 1876a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1877a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1878a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub"); 1879a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1880a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 1881a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1882a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1883a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1884a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1885a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1886f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 188787415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFSub(Ops.LHS, Ops.RHS, "sub"); 18882eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner 18897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 18902add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 18911f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 18929a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Must have binary (not unary) expr here. Unary pointer increment doesn't 18939a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 18949a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 18959a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 18969a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner if (BinOp->getLHS()->getType()->isPointerType() && 18979a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<PointerType>()->isVariableArrayType()) { 1898daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size for 1899daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-int 1900daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the division needs to account for the VLA size for 1901daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-ptr. 19029a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer subtraction"); 1903daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 1904daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 19059a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const QualType LHSType = BinOp->getLHS()->getType(); 190614108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType LHSElementType = LHSType->getPointeeType(); 19078c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar if (!isa<llvm::PointerType>(Ops.RHS->getType())) { 19088c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - int 19098c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *Idx = Ops.RHS; 19108c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 19117cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 19128c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Zero or sign extend the pointer value based on whether the index is 19138c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // signed or not. 191477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *IdxType = CGF.IntPtrTy; 19159a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner if (BinOp->getRHS()->getType()->isSignedIntegerType()) 19168c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 19178c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar else 19188c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 19198c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 19208c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateNeg(Idx, "sub.ptr.neg"); 1921b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar 1922db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1923c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = LHSElementType->getAs<ObjCObjectType>()) { 1924db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 19254a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1926199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext(). 1927199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getTypeSizeInChars(OIT).getQuantity()); 19282a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 19293c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 19302a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 19312a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr"); 19322a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1933db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 19342a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1935b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // Explicitly handle GNU void* and function pointer arithmetic 1936db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // extensions. The GNU void* casts amount to no-ops since our void* type is 1937db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // i8*, but this is future proof. 1938b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 19393c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1940b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1941b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr"); 1942b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1943db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1944db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1945664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ops.LHS, Idx, "sub.ptr"); 1946820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar } else { 19478c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - pointer 19488c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *LHS = Ops.LHS; 19498c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *RHS = Ops.RHS; 1950db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1951199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ElementSize; 1952820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar 1953e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Handle GCC extension for pointer arithmetic on void* and function pointer 1954e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // types. 1955e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 1956199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CharUnits::One(); 19578c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } else { 1958199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CGF.getContext().getTypeSizeInChars(LHSElementType); 19598c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 1960db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19618c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar const llvm::Type *ResultType = ConvertType(Ops.Ty); 19628c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); 19638c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 19648c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 1965db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1966e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Optimize out the shift for element size of 1. 1967199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck if (ElementSize.isOne()) 1968e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner return BytesBetween; 1969df1109434abd465a4db2e6f69ec2688866660367Dan Gohman 1970df1109434abd465a4db2e6f69ec2688866660367Dan Gohman // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 1971db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // pointer difference in C is only defined in the case where both operands 1972db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // are pointing to elements of an array. 1973199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck Value *BytesPerElt = 1974199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck llvm::ConstantInt::get(ResultType, ElementSize.getQuantity()); 1975df1109434abd465a4db2e6f69ec2688866660367Dan Gohman return Builder.CreateExactSDiv(BytesBetween, BytesPerElt, "sub.ptr.div"); 19767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 19777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 19807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 19817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 19827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 19837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 19847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1985db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1986be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 1987be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1988be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1989be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1990be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1991be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 199215037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 1993be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 1994be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 1995be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 19967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateShl(Ops.LHS, RHS, "shl"); 19977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 20007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 20017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 20027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 20037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 20047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 2005db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2006be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 2007be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 2008be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 2009be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 2010be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 2011be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 201215037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 2013be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 2014be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 2015be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 2016f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasUnsignedIntegerRepresentation()) 20177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 20187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 20197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 20207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2021aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsevenum IntrinsicType { VCMPEQ, VCMPGT }; 2022aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev// return corresponding comparison intrinsic for given vector type 2023aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsevstatic llvm::Intrinsic::ID GetIntrinsic(IntrinsicType IT, 2024aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev BuiltinType::Kind ElemKind) { 2025aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev switch (ElemKind) { 2026aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev default: assert(0 && "unexpected element type"); 2027aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Char_U: 2028aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UChar: 2029aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 2030aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtub_p; 2031aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2032aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Char_S: 2033aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::SChar: 2034aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 2035aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsb_p; 2036aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2037aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UShort: 2038aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 2039aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtuh_p; 2040aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2041aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Short: 2042aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 2043aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsh_p; 2044aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2045aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UInt: 2046aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::ULong: 2047aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 2048aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtuw_p; 2049aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2050aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Int: 2051aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Long: 2052aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 2053aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsw_p; 2054aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2055aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Float: 2056aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p : 2057aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtfp_p; 2058aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2059aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2060aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return llvm::Intrinsic::not_intrinsic; 2061aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev} 2062aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 20637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 20647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc) { 20657f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 20664f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *Result; 20677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner QualType LHSTy = E->getLHS()->getType(); 20680bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) { 20692de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_EQ || 20702de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall E->getOpcode() == BO_NE); 2071d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *LHS = CGF.EmitScalarExpr(E->getLHS()); 2072d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *RHS = CGF.EmitScalarExpr(E->getRHS()); 20730bab0cdab751248ca389a5592bcb70eac5d39260John McCall Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison( 20742de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE); 2075b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else if (!LHSTy->isAnyComplexType()) { 20767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS = Visit(E->getLHS()); 20777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 2078db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2079aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // If AltiVec, the comparison results in a numeric type, so we use 2080aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // intrinsics comparing vectors and giving 0 or 1 as a result 2081aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (LHSTy->isVectorType() && CGF.getContext().getLangOptions().AltiVec) { 2082aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // constants for mapping CR6 register bits to predicate result 2083aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6; 2084aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2085aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ID ID = llvm::Intrinsic::not_intrinsic; 2086aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2087aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // in several cases vector arguments order will be reversed 2088aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Value *FirstVecArg = LHS, 2089aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev *SecondVecArg = RHS; 2090aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2091aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev QualType ElTy = LHSTy->getAs<VectorType>()->getElementType(); 2092f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const BuiltinType *BTy = ElTy->getAs<BuiltinType>(); 2093aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev BuiltinType::Kind ElementKind = BTy->getKind(); 2094aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2095aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev switch(E->getOpcode()) { 2096aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev default: assert(0 && "is not a comparison operation"); 2097aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_EQ: 2098aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2099aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPEQ, ElementKind); 2100aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2101aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_NE: 2102aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2103aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPEQ, ElementKind); 2104aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2105aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_LT: 2106aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2107aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2108aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2109aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2110aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_GT: 2111aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2112aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2113aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2114aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_LE: 2115aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (ElementKind == BuiltinType::Float) { 2116aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2117aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 2118aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2119aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2120aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev else { 2121aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2122aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2123aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2124aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2125aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_GE: 2126aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (ElementKind == BuiltinType::Float) { 2127aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2128aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 2129aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2130aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev else { 2131aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2132aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2133aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2134aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2135aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2136aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2137aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2138aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Value *CR6Param = llvm::ConstantInt::get(CGF.Int32Ty, CR6); 2139aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Function *F = CGF.CGM.getIntrinsic(ID); 2140aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Result = Builder.CreateCall3(F, CR6Param, FirstVecArg, SecondVecArg, ""); 2141aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 2142aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2143aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2144f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (LHS->getType()->isFPOrFPVectorTy()) { 21457a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 21467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 2147f60946222721d9ba3c059563935c17b84703187aDouglas Gregor } else if (LHSTy->hasSignedIntegerRepresentation()) { 2148ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 21497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 21507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 2151ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman // Unsigned integers and pointers. 2152ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 21537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 21547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 21559c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner 21569c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // If this is a vector comparison, sign extend the result to the appropriate 21579c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // vector integer type and return it (don't convert to bool). 21589c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner if (LHSTy->isVectorType()) 21599c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 2160db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 21627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex Comparison: can only be an equality comparison. 21637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 21647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 2165db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2166183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType CETy = LHSTy->getAs<ComplexType>()->getElementType(); 2167db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21684f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *ResultR, *ResultI; 21697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (CETy->isRealFloatingType()) { 21707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 21717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 21727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 21737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 21747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 21757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex comparisons can only be equality comparisons. As such, signed 21767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // and unsigned opcodes are the same. 21777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 21787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 21797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 21807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 21817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2182db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21832de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (E->getOpcode() == BO_EQ) { 21847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 21857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 21862de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_NE && 21877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Complex comparison other than == or != ?"); 21887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 21897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 21907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 219132f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes 219232f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 21937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 21947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 21957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 21967f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool Ignore = TestAndClearIgnoreResultAssign(); 21977f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 21987f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __block variables need to have the rhs evaluated first, plus this should 21997f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // improve codegen just a little. 22007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 2201b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHS = EmitCheckedLValue(E->getLHS()); 2202db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2203ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar // Store the value into the LHS. Bit-fields are handled specially 2204371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // because the result is altered by the store, i.e., [C99 6.5.16p1] 2205371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // 'An assignment expression has the value of the left operand after 2206daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // the assignment...'. 2207d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHS.isBitField()) 2208d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType(), 2209d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar &RHS); 2210d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 2211ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType()); 2212d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2213d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 22147f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 22157f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 2216d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2217b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 2218b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!CGF.getContext().getLangOptions().CPlusPlus) 2219b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return RHS; 2220b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 2221d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 2222119a1c6c4029d30cae7b31a2826aa0ff70d01668John McCall if (LHS.isPropertyRef()) 2223d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2224d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2225d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 2226d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 2227d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2228d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2229d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 22307f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitLoadOfLValue(LHS, E->getType()); 22317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 22327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 22337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 22347804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 22357804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 223620eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 223720eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 && X, just emit X without inserting the control flow. 223820eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 223920eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == 1) { // If we have 1 && X, just emit X. 22400946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 22417804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 22427804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 22430946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2244db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22457804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 224620eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 22477804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::Constant::getNullValue(ResTy); 22480946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2249db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22509615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 22519615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 225220eb09d562b80420a3328be789547af354bf3e36Chris Lattner 2253150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 2254150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2255f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is false, go to the failure (cont) block. 2256f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 2257f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2258f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2259f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be false. Start 2260f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 22610032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 22620032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2263f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 2264f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2265f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 22663b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 2267db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2268150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 22697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 22707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2271150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2272db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 22747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2275f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2276f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2277f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 22787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 22797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2280db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 22827804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 22837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 22847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 22857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 22867804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 22877804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 228820eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 228920eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 || X, just emit X without inserting the control flow. 229020eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 229120eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == -1) { // If we have 0 || X, just emit X. 22920946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 22937804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 22947804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 22950946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2296db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22977804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 229820eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 22997804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::ConstantInt::get(ResTy, 1); 23000946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2301db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23029615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 23039615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 2304db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2305150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 2306150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2307f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is true, go to the success (cont) block. 2308f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 2309f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2310f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2311f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be true. Start 2312f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 23130032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 23140032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2315f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 2316f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2317f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 23183b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 2319f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2320150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 232133da07db112f4877f6ab13e20db08b9bb86a0c2eAnders Carlsson 2322f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit the RHS condition as a bool value. 23237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 23247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2325db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2326150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2327db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 23297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2330db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2331f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2332f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 2333f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBlock(ContBlock); 23347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2335db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23367f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 23377804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 23387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 23412a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E->getLHS()); 2342a448fb2da03ece39978784793eea68760e8205a1Daniel Dunbar CGF.EnsureInsertPoint(); 23437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getRHS()); 23447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 23477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Other Operators 23487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 23497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23509802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 23519802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// expression is cheap enough and side-effect-free enough to evaluate 23529802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// unconditionally instead of conditionally. This is used to convert control 23539802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// flow into selects in some cases. 2354df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stumpstatic bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 2355df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CodeGenFunction &CGF) { 23569802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) 2357df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr(), CGF); 2358db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23599802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // TODO: Allow anything we can constant fold to an integer or fp constant. 23609802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) || 23619802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner isa<FloatingLiteral>(E)) 23629802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2363db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23649802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // Non-volatile automatic variables too, to get "cond ? X : Y" where 23659802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // X and Y are local variables. 23669802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 23679802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 2368df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (VD->hasLocalStorage() && !(CGF.getContext() 2369df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .getCanonicalType(VD->getType()) 2370df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .isVolatileQualified())) 23719802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2372db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23739802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return false; 23749802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner} 23759802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 23769802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 23777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter:: 23787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerVisitConditionalOperator(const ConditionalOperator *E) { 23797f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 238031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the condition constant folds and can be elided, try to avoid emitting 238131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the condition and the dead arm. 238231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getCond())){ 2383c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner Expr *Live = E->getLHS(), *Dead = E->getRHS(); 238431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (Cond == -1) 2385c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner std::swap(Live, Dead); 2386db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 238731a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the dead side doesn't have labels we need, and if the Live side isn't 238831a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the gnu missing ?: extension (which we could handle, but don't bother 238931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // to), just emit the Live part. 239031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if ((!Dead || !CGF.ContainsLabel(Dead)) && // No labels in dead part 239131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Live) // Live part isn't missing. 239231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return Visit(Live); 2393c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner } 2394db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23956155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // OpenCL: If the condition is a vector, we can treat this condition like 23966155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // the select function. 23976155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (CGF.getContext().getLangOptions().OpenCL 23986155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman && E->getCond()->getType()->isVectorType()) { 23996155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *CondV = CGF.EmitScalarExpr(E->getCond()); 24006155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *LHS = Visit(E->getLHS()); 24016155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *RHS = Visit(E->getRHS()); 24026155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24036155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::Type *condType = ConvertType(E->getCond()->getType()); 24046155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::VectorType *vecTy = cast<llvm::VectorType>(condType); 24056155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24066155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman unsigned numElem = vecTy->getNumElements(); 24076155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::Type *elemType = vecTy->getElementType(); 24086155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24096155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman std::vector<llvm::Constant*> Zvals; 24106155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman for (unsigned i = 0; i < numElem; ++i) 24116155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman Zvals.push_back(llvm::ConstantInt::get(elemType,0)); 24126155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24136155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *zeroVec = llvm::ConstantVector::get(Zvals); 24146155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec); 24156155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp = Builder.CreateSExt(TestMSB, 24166155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::VectorType::get(elemType, 24176155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman numElem), 24186155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman "sext"); 24196155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp2 = Builder.CreateNot(tmp); 24206155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24216155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // Cast float to int to perform ANDs if necessary. 24226155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *RHSTmp = RHS; 24236155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *LHSTmp = LHS; 24246155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman bool wasCast = false; 24256155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType()); 24266155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (rhsVTy->getElementType()->isFloatTy()) { 24276155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType()); 24286155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman LHSTmp = Builder.CreateBitCast(LHS, tmp->getType()); 24296155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman wasCast = true; 24306155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 24316155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24326155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2); 24336155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp); 24346155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond"); 24356155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (wasCast) 24366155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman tmp5 = Builder.CreateBitCast(tmp5, RHS->getType()); 2437db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24386155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman return tmp5; 24396155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 24406155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24419802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // If this is a really simple expression (like x ? 4 : 5), emit this as a 24429802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // select instead of as control flow. We can only do this if it is cheap and 2443531a550531c144a58438f187816abbf1879e1c4eChris Lattner // safe to evaluate the LHS and RHS unconditionally. 2444df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (E->getLHS() && isCheapEnoughToEvaluateUnconditionally(E->getLHS(), 2445df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CGF) && 2446df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump isCheapEnoughToEvaluateUnconditionally(E->getRHS(), CGF)) { 24479802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *CondV = CGF.EvaluateExprAsBool(E->getCond()); 24489802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *LHS = Visit(E->getLHS()); 24499802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *RHS = Visit(E->getRHS()); 24509802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 24519802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner } 2452db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2453be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 2454be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 24559615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 2456150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 2457150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 2458af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian 2459db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If we don't have the GNU missing condition extension, emit a branch on bool 2460db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // the normal way. 246112d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner if (E->getLHS()) { 246212d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for 246312d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the branch on bool. 246412d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 246512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner } else { 246612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, for the ?: extension, evaluate the conditional and then 246712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // convert it to bool the hard way. We do this explicitly because we need 246812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the unconverted value for the missing middle value of the ?:. 2469af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Expr *save = E->getSAVE(); 2470af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian assert(save && "VisitConditionalOperator - save is null"); 2471af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian // Intentianlly not doing direct assignment to ConditionalSaveExprs[save] !! 2472af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *SaveVal = CGF.EmitScalarExpr(save); 2473af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian CGF.ConditionalSaveExprs[save] = SaveVal; 2474af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *CondVal = Visit(E->getCond()); 247512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // In some cases, EmitScalarConversion will delete the "CondVal" expression 247612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // if there are no extra uses (an optimization). Inhibit this by making an 247712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // extra dead use, because we're going to add a use of CondVal later. We 247812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // don't use the builder for this, because we don't want it to get optimized 247912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // away. This leaves dead code, but the ?: extension isn't common. 248012d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner new llvm::BitCastInst(CondVal, CondVal->getType(), "dummy?:holder", 248112d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner Builder.GetInsertBlock()); 2482db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2483035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Value *CondBoolVal = 2484035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.EmitScalarConversion(CondVal, E->getCond()->getType(), 2485035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.getContext().BoolTy); 2486035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock); 2487035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner } 2488fb6fa30a9b06670deb14f862dddbc49a12552939Anders Carlsson 24897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(LHSBlock); 2490150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 2491af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *LHS = Visit(E->getTrueExpr()); 2492150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2493db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHSBlock = Builder.GetInsertBlock(); 2495150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall Builder.CreateBr(ContBlock); 2496db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 2498150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 2499856226c37ff10955c7f3f07ce6fa9522da23a3a5Eli Friedman Value *RHS = Visit(E->getRHS()); 2500150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 2501db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2502150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall RHSBlock = Builder.GetInsertBlock(); 25037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 2504db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 250548daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman // If the LHS or RHS is a throw expression, it will be legitimately null. 250648daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!LHS) 250748daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return RHS; 250848daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!RHS) 250948daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return LHS; 2510db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Create a PHI node for the real part. 25127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond"); 25137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->reserveOperandSpace(2); 25147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(LHS, LHSBlock); 25157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHS, RHSBlock); 25167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return PN; 25177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 25187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 25197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 25207976932a1c256d447316ffac58e9821417725e34Eli Friedman return Visit(E->getChosenSubExpr(CGF.getContext())); 25217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 25227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 25232202bce80fc72d067cbe67dc1512f7b45351fd31Chris LattnerValue *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 25244fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 2525ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 2526ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 2527ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson // If EmitVAArg fails, we fall back to the LLVM instruction. 2528db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (!ArgPtr) 2529ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 2530ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 25317f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // FIXME Volatility. 2532ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateLoad(ArgPtr); 25337c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson} 25347c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 2535df6b68c9487aed2042c7fc23db10a79f89083a11Mike StumpValue *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *BE) { 25360892099dbc640720400a1d9decd2733a09d733e5Mike Stump return CGF.BuildBlockLiteralTmp(BE); 2537df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump} 2538df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 25397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 25407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Entry Point into this File 25417f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 25427f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2543db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitScalarExpr - Emit the computation of the specified expression of scalar 2544db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type, ignoring the result. 25457f79f9be5916c51c35da4f126b7c12596a101607Mike StumpValue *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 25467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E && !hasAggregateLLVMType(E->getType()) && 25477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Invalid scalar expression to emit"); 2548db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25497f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return ScalarExprEmitter(*this, IgnoreResultAssign) 25507f79f9be5916c51c35da4f126b7c12596a101607Mike Stump .Visit(const_cast<Expr*>(E)); 25517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 25523707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 25533707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 25543707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 25554f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 25564f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 25573707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 25583707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner "Invalid scalar expression to emit"); 25593707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 25603707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 25614f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 2562db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 2563db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 2564db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 25654f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 25664f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, 25674f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 25689b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 25694f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner "Invalid complex -> scalar conversion"); 25704f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 25714f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner DstTy); 25724f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 2573cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 25748c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 25758c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *CodeGenFunction:: 25768c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 25778c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 25788c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre); 25798c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 25808c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2581820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz JahanianLValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 2582820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian llvm::Value *V; 2583820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // object->isa or (*object).isa 2584820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // Generate code as for: *(Class*)object 25855ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian // build Class* type 25865ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian const llvm::Type *ClassPtrTy = ConvertType(E->getType()); 25875ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian 2588820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Expr *BaseExpr = E->getBase(); 25897eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (BaseExpr->isRValue()) { 25905ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = CreateTempAlloca(ClassPtrTy, "resval"); 25915ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian llvm::Value *Src = EmitScalarExpr(BaseExpr); 25925ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian Builder.CreateStore(Src, V); 25939f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue( 25949f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar MakeAddrLValue(V, E->getType()), E->getType()); 25959f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar } else { 25969f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar if (E->isArrow()) 25979f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr); 25989f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar else 25999f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = EmitLValue(BaseExpr).getAddress(); 26005ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 2601820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 2602820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // build Class* type 2603820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian ClassPtrTy = ClassPtrTy->getPointerTo(); 2604820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian V = Builder.CreateBitCast(V, ClassPtrTy); 26059f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(V, E->getType()); 2606820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian} 2607820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 26086a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 26092a41637a995affa1563f4d82a8b026e326a2faa0John McCallLValue CodeGenFunction::EmitCompoundAssignmentLValue( 26106a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E) { 26116a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor ScalarExprEmitter Scalar(*this); 2612d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *Result = 0; 26136a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor switch (E->getOpcode()) { 26146a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#define COMPOUND_OP(Op) \ 26152de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_##Op##Assign: \ 26166a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 2617d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result) 26186a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Mul); 26196a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Div); 26206a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Rem); 26216a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Add); 26226a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Sub); 26236a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shl); 26246a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shr); 26256a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(And); 26266a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Xor); 26276a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Or); 26286a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#undef COMPOUND_OP 26296a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 26302de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemD: 26312de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemI: 26322de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 26332de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Div: 26342de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Rem: 26352de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 26362de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 26372de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shl: 26382de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shr: 26392de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LT: 26402de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GT: 26412de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LE: 26422de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GE: 26432de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_EQ: 26442de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_NE: 26452de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_And: 26462de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Xor: 26472de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Or: 26482de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LAnd: 26492de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LOr: 26502de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Assign: 26512de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Comma: 26526a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor assert(false && "Not valid compound assignment operators"); 26536a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor break; 26546a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor } 26556a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 26566a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor llvm_unreachable("Unhandled compound assignment operator"); 26576a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 2658