CGExprScalar.cpp revision f4c7371fb1d3cebcfb40abad4537bb82515704ea
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 3058c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *EmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 3068c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre); 3078c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 3088c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 3097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryAddrOf(const UnaryOperator *E) { 310d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // If the sub-expression is an instance member reference, 311d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // EmitDeclRefLValue will magically emit it with the appropriate 312d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // value as the "address". 3137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLValue(E->getSubExpr()).getAddress(); 3147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 315fd569004b78124c1041feee75a1e311166268c8dJohn McCall Value *VisitUnaryDeref(const UnaryOperator *E) { 316fd569004b78124c1041feee75a1e311166268c8dJohn McCall if (E->getType()->isVoidType()) 317fd569004b78124c1041feee75a1e311166268c8dJohn McCall return Visit(E->getSubExpr()); // the actual value should be unused 318fd569004b78124c1041feee75a1e311166268c8dJohn McCall return EmitLoadOfLValue(E); 319fd569004b78124c1041feee75a1e311166268c8dJohn McCall } 3207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryPlus(const UnaryOperator *E) { 3217f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // This differs from gcc, though, most likely due to a bug in gcc. 3227f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 3237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 3247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryMinus (const UnaryOperator *E); 3267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryNot (const UnaryOperator *E); 3277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryLNot (const UnaryOperator *E); 32846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryReal (const UnaryOperator *E); 32946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Value *VisitUnaryImag (const UnaryOperator *E); 3307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitUnaryExtension(const UnaryOperator *E) { 3317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getSubExpr()); 3327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 3338ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 3345f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson // C++ 33504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner Value *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 33604421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 33704421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 3385f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson Value *VisitCXXThisExpr(CXXThisExpr *TE) { 3395f4307b7ba164b03c853c8d3eb4674d33f8967a6Anders Carlsson return CGF.LoadCXXThis(); 340db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 341db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3424765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall Value *VisitExprWithCleanups(ExprWithCleanups *E) { 3434765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall return CGF.EmitExprWithCleanups(E).getScalarVal(); 3447f6ad153565245026c7569314f65a4d4ff4ac41fAnders Carlsson } 345a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson Value *VisitCXXNewExpr(const CXXNewExpr *E) { 346a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson return CGF.EmitCXXNewExpr(E); 347a00703dccbdc6cc4a293db38477dea7db5538c7eAnders Carlsson } 34860e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson Value *VisitCXXDeleteExpr(const CXXDeleteExpr *E) { 34960e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson CGF.EmitCXXDeleteExpr(E); 35060e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson return 0; 35160e282cc1e508be327b0481cecedc206873cb86aAnders Carlsson } 3529dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman Value *VisitUnaryTypeTraitExpr(const UnaryTypeTraitExpr *E) { 3530dfd848fa4c9664852ba8c929a8bd3fce93ddca2Sebastian Redl return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue()); 3549dfebdcdcdcc0cad8a3ef205d33b84f33233072bEli Friedman } 355db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 3566ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet Value *VisitBinaryTypeTraitExpr(const BinaryTypeTraitExpr *E) { 357f187237d916afa97c491ac32fe98be7d335c5b63Francois Pichet return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue()); 3586ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet } 3596ad6f2848d7652ab2991286eb48be440d3493b28Francois Pichet 360a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor Value *VisitCXXPseudoDestructorExpr(const CXXPseudoDestructorExpr *E) { 361a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // C++ [expr.pseudo]p1: 362db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // The result shall only be used as the operand for the function call 363a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // operator (), and the result of such a call has type void. The only 364a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // effect is the evaluation of the postfix-expression before the dot or 365a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor // arrow. 366a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor CGF.EmitScalarExpr(E->getBase()); 367a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor return 0; 368a71d819bb8f50c28938db0f2867d3fb6e2ce5910Douglas Gregor } 369db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 370c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson Value *VisitCXXNullPtrLiteralExpr(const CXXNullPtrLiteralExpr *E) { 371a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson return EmitNullValue(E->getType()); 372c1eb14a66fdd955aff3f957a5843295f27952bddAnders Carlsson } 373756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 374756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson Value *VisitCXXThrowExpr(const CXXThrowExpr *E) { 375756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson CGF.EmitCXXThrowExpr(E); 376756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson return 0; 377756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson } 378756b5c4f9d52642d87d1948bee58f97a4f795b24Anders Carlsson 37998294def01c97e127fa6d812ebd944d37212828aSebastian Redl Value *VisitCXXNoexceptExpr(const CXXNoexceptExpr *E) { 38098294def01c97e127fa6d812ebd944d37212828aSebastian Redl return llvm::ConstantInt::get(Builder.getInt1Ty(), E->getValue()); 38198294def01c97e127fa6d812ebd944d37212828aSebastian Redl } 38298294def01c97e127fa6d812ebd944d37212828aSebastian Redl 3837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Binary Operators. 3847f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitMul(const BinOpInfo &Ops) { 385f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 386a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 387a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 388a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWMul(Ops.LHS, Ops.RHS, "mul"); 389a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 390a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 391a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 392a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 393a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 394a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 395a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 396f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 39787415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFMul(Ops.LHS, Ops.RHS, "mul"); 3987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul"); 3997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4008023030f76d334355b73d9c675d3870858aaf4fdChris Lattner bool isTrapvOverflowBehavior() { 4018023030f76d334355b73d9c675d3870858aaf4fdChris Lattner return CGF.getContext().getLangOptions().getSignedOverflowBehavior() 4028023030f76d334355b73d9c675d3870858aaf4fdChris Lattner == LangOptions::SOB_Trapping; 4038023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 4042add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Create a binary op that checks for overflow. 4052add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump /// Currently only supports +, - and *. 4062add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *EmitOverflowCheckedBinOp(const BinOpInfo &Ops); 4078023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Emit the overflow BB when -ftrapv option is activated. 4088023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitOverflowBB(llvm::BasicBlock *overflowBB) { 4098023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(overflowBB); 4108023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Function *Trap = CGF.CGM.getIntrinsic(llvm::Intrinsic::trap); 4118023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCall(Trap); 4128023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateUnreachable(); 4138023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 4148023030f76d334355b73d9c675d3870858aaf4fdChris Lattner // Check for undefined division and modulus behaviors. 4158023030f76d334355b73d9c675d3870858aaf4fdChris Lattner void EmitUndefinedBehaviorIntegerDivAndRemCheck(const BinOpInfo &Ops, 4168023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero,bool isDiv); 4177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitDiv(const BinOpInfo &Ops); 4187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitRem(const BinOpInfo &Ops); 4197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAdd(const BinOpInfo &Ops); 4207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitSub(const BinOpInfo &Ops); 4217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShl(const BinOpInfo &Ops); 4227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitShr(const BinOpInfo &Ops); 4237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitAnd(const BinOpInfo &Ops) { 4247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and"); 4257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitXor(const BinOpInfo &Ops) { 4277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor"); 4287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitOr (const BinOpInfo &Ops) { 4307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateOr(Ops.LHS, Ops.RHS, "or"); 4317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4331f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo EmitBinOps(const BinaryOperator *E); 4346a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 4356a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*F)(const BinOpInfo &), 436d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result); 4376a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 4383ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *EmitCompoundAssign(const CompoundAssignOperator *E, 4391f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Value *(ScalarExprEmitter::*F)(const BinOpInfo &)); 4401f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 4411f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Binary operators and binary compound assignment operators. 4421f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#define HANDLEBINOP(OP) \ 4433ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP(const BinaryOperator *E) { \ 4443ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return Emit ## OP(EmitBinOps(E)); \ 4453ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner } \ 4463ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) { \ 4473ccf774256382ef9aa95028eaad82f54a3d0b0adChris Lattner return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP); \ 4481f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 4497177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Mul) 4507177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Div) 4517177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Rem) 4527177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Add) 4537177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Sub) 4547177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shl) 4557177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Shr) 4567177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(And) 4577177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Xor) 4587177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar HANDLEBINOP(Or) 4591f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner#undef HANDLEBINOP 4608c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar 4617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Comparisons. 4627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc, 4637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc); 4647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#define VISITCOMP(CODE, UI, SI, FP) \ 4657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBin##CODE(const BinaryOperator *E) { \ 4667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \ 4677f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::FCmpInst::FP); } 4687177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT) 4697177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT) 4707177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE) 4717177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE) 4727177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ) 4737177dee8aee4b432911c91f1b788963bec0cac9fDaniel Dunbar VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE) 4747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner#undef VISITCOMP 475db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 4767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinAssign (const BinaryOperator *E); 4777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLAnd (const BinaryOperator *E); 4797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinLOr (const BinaryOperator *E); 4807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitBinComma (const BinaryOperator *E); 4817f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 48225b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemD(const Expr *E) { return EmitLoadOfLValue(E); } 48325b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman Value *VisitBinPtrMemI(const Expr *E) { return EmitLoadOfLValue(E); } 48425b825d1a48fb4d64cb553bef7a316469e89c46aEli Friedman 4857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Other Operators. 486df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump Value *VisitBlockExpr(const BlockExpr *BE); 4877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitConditionalOperator(const ConditionalOperator *CO); 4887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitChooseExpr(ChooseExpr *CE); 4897c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson Value *VisitVAArgExpr(VAArgExpr *VE); 4907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) { 4917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return CGF.EmitObjCStringLiteral(E); 4927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 4937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner}; 4947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} // end anonymous namespace. 4957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 4967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 4977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Utilities 4987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 4997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 5009abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner/// EmitConversionToBool - Convert the specified expression value to a 5013420d0de2c52fedf771d7ef20522f6080233e377Chris Lattner/// boolean (i1) truth value. This is equivalent to "Val != 0". 5029abc84e7ac4db891209fe67cc3a8c9690dc886efChris LattnerValue *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) { 503467b27b9a24bdc823218ad1ad0e37673b6cc1e83John McCall assert(SrcType.isCanonical() && "EmitScalarConversion strips typedefs"); 504db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 505daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (SrcType->isRealFloatingType()) 506daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitFloatToBoolConversion(Src); 507db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5080bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = dyn_cast<MemberPointerType>(SrcType)) 5090bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, Src, MPT); 510db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 511d1d66bcd6914ff82abdfa88dd25bb0b74cde3b99Daniel Dunbar assert((SrcType->isIntegerType() || isa<llvm::PointerType>(Src->getType())) && 5129abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner "Unknown scalar type to convert"); 513db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 514daa8e4e888758d55a7a759dd4a91b83921cef222John McCall if (isa<llvm::IntegerType>(Src->getType())) 515daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitIntToBoolConversion(Src); 516db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 517daa8e4e888758d55a7a759dd4a91b83921cef222John McCall assert(isa<llvm::PointerType>(Src->getType())); 518daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitPointerToBoolConversion(Src); 5199abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner} 5209abc84e7ac4db891209fe67cc3a8c9690dc886efChris Lattner 5213707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 5223707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 5234f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType, 5244f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstType) { 5259619662a1d42e2008b865d3459c0677e149dad1bChris Lattner SrcType = CGF.getContext().getCanonicalType(SrcType); 5269619662a1d42e2008b865d3459c0677e149dad1bChris Lattner DstType = CGF.getContext().getCanonicalType(DstType); 5273707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (SrcType == DstType) return Src; 528db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 529cf289083ab007264fa3ea96d92f133339aee5d2dChris Lattner if (DstType->isVoidType()) return 0; 530db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5313707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 532ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstType->isBooleanType()) 533ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return EmitConversionToBool(Src, SrcType); 534db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5353707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner const llvm::Type *DstTy = ConvertType(DstType); 5363707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 5373707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Ignore conversions like int -> uint. 5383707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (Src->getType() == DstTy) 5393707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Src; 5403707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 541db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle pointer conversions next: pointers can only be converted to/from 542db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // other pointers and integers. Check for pointer types in terms of LLVM, as 543db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // some native types (like Obj-C id) may map to a pointer type. 544270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(DstTy)) { 5453707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // The source value may be an integer, or a pointer. 546191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson if (isa<llvm::PointerType>(Src->getType())) 5473707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return Builder.CreateBitCast(Src, DstTy, "conv"); 548191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 5493707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?"); 55025615424741bcce31fe52c896f76268f0307f00dEli Friedman // First, convert to the correct width so that we control the kind of 55125615424741bcce31fe52c896f76268f0307f00dEli Friedman // extension. 55277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 55325615424741bcce31fe52c896f76268f0307f00dEli Friedman bool InputSigned = SrcType->isSignedIntegerType(); 55425615424741bcce31fe52c896f76268f0307f00dEli Friedman llvm::Value* IntResult = 55525615424741bcce31fe52c896f76268f0307f00dEli Friedman Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 55625615424741bcce31fe52c896f76268f0307f00dEli Friedman // Then, cast to pointer. 55725615424741bcce31fe52c896f76268f0307f00dEli Friedman return Builder.CreateIntToPtr(IntResult, DstTy, "conv"); 5583707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 559db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 560270cc66683b22d6bb0b4644f5a40f84d45edf119Daniel Dunbar if (isa<llvm::PointerType>(Src->getType())) { 5613707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Must be an ptr to int cast. 5623707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?"); 56350b5a30db40322880340e957ad7d6d8d60bb4c5bAnders Carlsson return Builder.CreatePtrToInt(Src, DstTy, "conv"); 5643707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 565db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 566213541a68a3e137d11d2cefb612c6cdb410d7e8eNate Begeman // A scalar can be splatted to an extended vector of the same element type 5672ef13e5abef0570a9f567b4671367275c05d4d34Nate Begeman if (DstType->isExtVectorType() && !SrcType->isVectorType()) { 5686fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Cast the scalar to element type 569183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType EltTy = DstType->getAs<ExtVectorType>()->getElementType(); 5706fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Elt = EmitScalarConversion(Src, SrcType, EltTy); 5716fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 5726fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Insert the element in element zero of an undef vector 57303e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson llvm::Value *UnV = llvm::UndefValue::get(DstTy); 57477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 5756fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 5766fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman 5776fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman // Splat the element across to all elements 5786fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 5796fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 5806fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman for (unsigned i = 0; i < NumElements; i++) 58177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 0)); 582db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5834a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 5846fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 5856fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman return Yay; 5866fe7c8aa8c7546743ecd0ac0138c2cf5d8155386Nate Begeman } 5874119d1aeca8016654d381ce079864058d1709571Nate Begeman 5883b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner // Allow bitcast from vector to integer/fp of the same size. 5897019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson if (isa<llvm::VectorType>(Src->getType()) || 5903b1ae004d0ee88fc029dad876ec5695f178ef3f6Chris Lattner isa<llvm::VectorType>(DstTy)) 5917019a9ea3f5d6f8cdf5e2e31f74b4df53e3ffcddAnders Carlsson return Builder.CreateBitCast(Src, DstTy, "conv"); 592db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5933707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner // Finally, we have the arithmetic types: real int/float. 5943707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(Src->getType())) { 5953707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner bool InputSigned = SrcType->isSignedIntegerType(); 596b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (isa<llvm::IntegerType>(DstTy)) 597b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv"); 598b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else if (InputSigned) 599b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateSIToFP(Src, DstTy, "conv"); 600b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 601b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateUIToFP(Src, DstTy, "conv"); 6023707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 603db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 604f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(Src->getType()->isFloatingPointTy() && "Unknown real conversion"); 6053707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner if (isa<llvm::IntegerType>(DstTy)) { 606b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstType->isSignedIntegerType()) 607b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToSI(Src, DstTy, "conv"); 608b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 609b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPToUI(Src, DstTy, "conv"); 6103707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner } 6113707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 612f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands assert(DstTy->isFloatingPointTy() && "Unknown real conversion"); 613b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson if (DstTy->getTypeID() < Src->getType()->getTypeID()) 614b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPTrunc(Src, DstTy, "conv"); 615b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson else 616b5ce097bb741733e24efd7803f29849be227f8ceAnders Carlsson return Builder.CreateFPExt(Src, DstTy, "conv"); 6173707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 6183707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 619db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 620db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 621db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 6224f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *ScalarExprEmitter:: 6234f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerEmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src, 6244f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, QualType DstTy) { 625ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Get the source element type. 626183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall SrcTy = SrcTy->getAs<ComplexType>()->getElementType(); 627db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 628ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Handle conversions to bool first, they are special: comparisons against 0. 629ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner if (DstTy->isBooleanType()) { 630ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner // Complex != 0 -> (Real != 0) | (Imag != 0) 631ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.first = EmitScalarConversion(Src.first, SrcTy, DstTy); 632ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy); 633ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner return Builder.CreateOr(Src.first, Src.second, "tobool"); 634ed70f0a53610e5e4d4a62cfc0be48d8c1539b5ffChris Lattner } 635db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 6364f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // C99 6.3.1.7p2: "When a value of complex type is converted to a real type, 6374f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // the imaginary part of the complex value is discarded and the value of the 6384f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner // real part is converted according to the conversion rules for the 639db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // corresponding real type. 6404f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return EmitScalarConversion(Src.first, SrcTy, DstTy); 6414f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 6424f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 643a40a9f31218c743e366322e34b59f0d4d4414198Anders CarlssonValue *ScalarExprEmitter::EmitNullValue(QualType Ty) { 6440bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = Ty->getAs<MemberPointerType>()) 6450bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 6460bab0cdab751248ca389a5592bcb70eac5d39260John McCall 6470bab0cdab751248ca389a5592bcb70eac5d39260John McCall return llvm::Constant::getNullValue(ConvertType(Ty)); 648a40a9f31218c743e366322e34b59f0d4d4414198Anders Carlsson} 6494f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 6507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Visitor Methods 6527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 6537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 6547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitExpr(Expr *E) { 655488e993a135ce700b982bf099c3d6b856301d642Daniel Dunbar CGF.ErrorUnsupported(E, "scalar expression"); 6567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (E->getType()->isVoidType()) 6577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return 0; 65803e205031b08669f05c41eed5b896fc94c4a12bbOwen Anderson return llvm::UndefValue::get(CGF.ConvertType(E->getType())); 6597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 6607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 661d38617c8a50f9729c254ab76cd359af797c6739bEli FriedmanValue *ScalarExprEmitter::VisitShuffleVectorExpr(ShuffleVectorExpr *E) { 66237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Vector Mask Case 66337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 2 || 6643f4cb120fe574f7b80864f52a1999502a4f3a83dRafael Espindola (E->getNumSubExprs() == 3 && E->getExpr(2)->getType()->isVectorType())) { 66577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *LHS = CGF.EmitScalarExpr(E->getExpr(0)); 66677b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *RHS = CGF.EmitScalarExpr(E->getExpr(1)); 66777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Mask; 66837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 66937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *LTy = cast<llvm::VectorType>(LHS->getType()); 67037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman unsigned LHSElts = LTy->getNumElements(); 67137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 67237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (E->getNumSubExprs() == 3) { 67337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = CGF.EmitScalarExpr(E->getExpr(2)); 67437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 67537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Shuffle LHS & RHS into one input vector. 67637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> concat; 67737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0; i != LHSElts; ++i) { 67877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i)); 67977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner concat.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 2*i+1)); 68037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 68137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 68237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* CV = llvm::ConstantVector::get(concat.begin(), concat.size()); 68337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHS = Builder.CreateShuffleVector(LHS, RHS, CV, "concat"); 68437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman LHSElts *= 2; 68537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } else { 68637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = RHS; 68737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 68837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 68937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *MTy = cast<llvm::VectorType>(Mask->getType()); 69037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant* EltMask; 69137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 69237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Treat vec3 like vec4. 69337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) 69437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 69537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+2))-1); 69637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else if ((LHSElts == 3) && (E->getNumSubExprs() == 2)) 69737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 69837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts+1))-1); 69937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman else 70037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman EltMask = llvm::ConstantInt::get(MTy->getElementType(), 70137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman (1 << llvm::Log2_32(LHSElts))-1); 70237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 70337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Mask off the high bits of each shuffle index. 70437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant *, 32> MaskV; 70537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) 70637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MaskV.push_back(EltMask); 70737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 70837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* MaskBits = llvm::ConstantVector::get(MaskV.begin(), MaskV.size()); 70937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Mask = Builder.CreateAnd(Mask, MaskBits, "mask"); 71037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 71137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = undef 71237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // mask = mask & maskbits 71337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // for each elt 71437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // n = extract mask i 71537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // x = extract val n 71637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // newv = insert newv, x, i 71737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *RTy = llvm::VectorType::get(LTy->getElementType(), 71837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman MTy->getNumElements()); 71937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value* NewV = llvm::UndefValue::get(RTy); 72037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 0, e = MTy->getNumElements(); i != e; ++i) { 72177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Indx = llvm::ConstantInt::get(CGF.Int32Ty, i); 72237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateExtractElement(Mask, Indx, "shuf_idx"); 72377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Indx = Builder.CreateZExt(Indx, CGF.Int32Ty, "idx_zext"); 72437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 72537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 72637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if ((LHSElts == 6) && (E->getNumSubExprs() == 3)) { 72737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *cmpIndx, *newIndx; 72877b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner cmpIndx = Builder.CreateICmpUGT(Indx, 72977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::ConstantInt::get(CGF.Int32Ty, 3), 73037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "cmp_shuf_idx"); 73177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner newIndx = Builder.CreateSub(Indx, llvm::ConstantInt::get(CGF.Int32Ty,1), 73237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman "shuf_idx_adj"); 73337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Indx = Builder.CreateSelect(cmpIndx, newIndx, Indx, "sel_shuf_idx"); 73437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 73537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman Value *VExt = Builder.CreateExtractElement(LHS, Indx, "shuf_elt"); 73637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman NewV = Builder.CreateInsertElement(NewV, VExt, Indx, "shuf_ins"); 73737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 73837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman return NewV; 739d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman } 74037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 741d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V1 = CGF.EmitScalarExpr(E->getExpr(0)); 742d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman Value* V2 = CGF.EmitScalarExpr(E->getExpr(1)); 74337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 74437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman // Handle vec3 special since the index will be off by one for the RHS. 74537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::SmallVector<llvm::Constant*, 32> indices; 74637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman for (unsigned i = 2; i < E->getNumSubExprs(); i++) { 74737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman llvm::Constant *C = cast<llvm::Constant>(CGF.EmitScalarExpr(E->getExpr(i))); 74837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman const llvm::VectorType *VTy = cast<llvm::VectorType>(V1->getType()); 74937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (VTy->getNumElements() == 3) { 75037b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C)) { 75137b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman uint64_t cVal = CI->getZExtValue(); 75237b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman if (cVal > 3) { 75337b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman C = llvm::ConstantInt::get(C->getType(), cVal-1); 75437b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 75537b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 75637b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 75737b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman indices.push_back(C); 75837b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman } 75937b6a5731a47f811d754f0d48aa93edf30e30513Nate Begeman 7604a28932dba03132dabbe70abdadcaae468dd7933Owen Anderson Value* SV = llvm::ConstantVector::get(indices.begin(), indices.size()); 761d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman return Builder.CreateShuffleVector(V1, V2, SV, "shuffle"); 762d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman} 76328665272c36cccb1014a6ea1217354b0519e2b59Eli FriedmanValue *ScalarExprEmitter::VisitMemberExpr(MemberExpr *E) { 76428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman Expr::EvalResult Result; 76528665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->Evaluate(Result, CGF.getContext()) && Result.Val.isInt()) { 76628665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman if (E->isArrow()) 76728665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman CGF.EmitScalarExpr(E->getBase()); 76828665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman else 76928665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman EmitLValue(E->getBase()); 77028665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 77128665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman } 77278ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel 77378ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // Emit debug info for aggregate now, if it was delayed to reduce 77478ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel // debug info size. 77578ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel CGDebugInfo *DI = CGF.getDebugInfo(); 77678ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (DI && CGF.CGM.getCodeGenOpts().LimitDebugInfo) { 77778ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel QualType PQTy = E->getBase()->IgnoreParenImpCasts()->getType(); 77878ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel if (const PointerType * PTy = dyn_cast<PointerType>(PQTy)) 77949c8465f14fc3b2e1a32c7016ad3fb4e2cf8d466Devang Patel if (FieldDecl *M = dyn_cast<FieldDecl>(E->getMemberDecl())) 78078ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel DI->getOrCreateRecordType(PTy->getPointeeType(), 78178ba3d46388f17b4fc5e63ed23b746dd4dea9547Devang Patel M->getParent()->getLocation()); 7827fa8ab2e77f5703d0adf14e4d98f1edc1e66505dDevang Patel } 78328665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman return EmitLoadOfLValue(E); 78428665272c36cccb1014a6ea1217354b0519e2b59Eli Friedman} 785d38617c8a50f9729c254ab76cd359af797c6739bEli Friedman 7867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) { 7877f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 7887f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 7897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Emit subscript expressions in rvalue context's. For most cases, this just 7907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // loads the lvalue formed by the subscript expr. However, we have to be 7917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // careful, because the base of a vector subscript is occasionally an rvalue, 7927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // so we can't get it as an lvalue. 7937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (!E->getBase()->getType()->isVectorType()) 7947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return EmitLoadOfLValue(E); 795db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 7967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the vector case. The base must be a vector, the index must be an 7977f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // integer value. 7987f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Base = Visit(E->getBase()); 7997f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Idx = Visit(E->getIdx()); 800daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman bool IdxSigned = E->getIdx()->getType()->isSignedIntegerType(); 80177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Idx = Builder.CreateIntCast(Idx, CGF.Int32Ty, IdxSigned, "vecidxcast"); 8027f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateExtractElement(Base, Idx, "vecext"); 8037f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 8047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 8050533b3020ca39898751d4200feed776861dcd1ceNate Begemanstatic llvm::Constant *getMaskElt(llvm::ShuffleVectorInst *SVI, unsigned Idx, 8060533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned Off, const llvm::Type *I32Ty) { 8070533b3020ca39898751d4200feed776861dcd1ceNate Begeman int MV = SVI->getMaskValue(Idx); 8080533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (MV == -1) 8090533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::UndefValue::get(I32Ty); 8100533b3020ca39898751d4200feed776861dcd1ceNate Begeman return llvm::ConstantInt::get(I32Ty, Off+MV); 8110533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 8120533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8130533b3020ca39898751d4200feed776861dcd1ceNate BegemanValue *ScalarExprEmitter::VisitInitListExpr(InitListExpr *E) { 8140533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool Ignore = TestAndClearIgnoreResultAssign(); 8150533b3020ca39898751d4200feed776861dcd1ceNate Begeman (void)Ignore; 8160533b3020ca39898751d4200feed776861dcd1ceNate Begeman assert (Ignore == false && "init list ignored"); 8170533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned NumInitElements = E->getNumInits(); 8180533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8190533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (E->hadArrayRangeDesignator()) 8200533b3020ca39898751d4200feed776861dcd1ceNate Begeman CGF.ErrorUnsupported(E, "GNU array range designator extension"); 8210533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8220533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VType = 8230533b3020ca39898751d4200feed776861dcd1ceNate Begeman dyn_cast<llvm::VectorType>(ConvertType(E->getType())); 8240533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8250533b3020ca39898751d4200feed776861dcd1ceNate Begeman // We have a scalar in braces. Just use the first element. 8260533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VType) 8270533b3020ca39898751d4200feed776861dcd1ceNate Begeman return Visit(E->getInit(0)); 8280533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8290533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned ResElts = VType->getNumElements(); 8300533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8310533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Loop over initializers collecting the Value for each, and remembering 8320533b3020ca39898751d4200feed776861dcd1ceNate Begeman // whether the source was swizzle (ExtVectorElementExpr). This will allow 8330533b3020ca39898751d4200feed776861dcd1ceNate Begeman // us to fold the shuffle for the swizzle into the shuffle for the vector 8340533b3020ca39898751d4200feed776861dcd1ceNate Begeman // initializer, since LLVM optimizers generally do not want to touch 8350533b3020ca39898751d4200feed776861dcd1ceNate Begeman // shuffles. 8360533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned CurIdx = 0; 8370533b3020ca39898751d4200feed776861dcd1ceNate Begeman bool VIsUndefShuffle = false; 8380533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *V = llvm::UndefValue::get(VType); 8390533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned i = 0; i != NumInitElements; ++i) { 8400533b3020ca39898751d4200feed776861dcd1ceNate Begeman Expr *IE = E->getInit(i); 8410533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *Init = Visit(IE); 8420533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::SmallVector<llvm::Constant*, 16> Args; 8430533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8440533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *VVT = dyn_cast<llvm::VectorType>(Init->getType()); 8450533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8460533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Handle scalar elements. If the scalar initializer is actually one 8470533b3020ca39898751d4200feed776861dcd1ceNate Begeman // element of a different vector of the same width, use shuffle instead of 8480533b3020ca39898751d4200feed776861dcd1ceNate Begeman // extract+insert. 8490533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!VVT) { 8500533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 8510533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ExtractElementInst *EI = cast<llvm::ExtractElementInst>(Init); 8520533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8530533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (EI->getVectorOperandType()->getNumElements() == ResElts) { 8540533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ConstantInt *C = cast<llvm::ConstantInt>(EI->getIndexOperand()); 8550533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *LHS = 0, *RHS = 0; 8560533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) { 8570533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undef -> shuffle (src, undef) 8580533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(C); 8590533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 1; j != ResElts; ++j) 86077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8610533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8620533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = EI->getVectorOperand(); 8630533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = V; 8640533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = true; 8650533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else if (VIsUndefShuffle) { 8660533b3020ca39898751d4200feed776861dcd1ceNate Begeman // insert into undefshuffle && size match -> shuffle (v, src) 8670533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVV = cast<llvm::ShuffleVectorInst>(V); 8680533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 86977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVV, j, 0, CGF.Int32Ty)); 87077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, 8710533b3020ca39898751d4200feed776861dcd1ceNate Begeman ResElts + C->getZExtValue())); 8720533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + 1; j != ResElts; ++j) 87377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 8740533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8750533b3020ca39898751d4200feed776861dcd1ceNate Begeman LHS = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 8760533b3020ca39898751d4200feed776861dcd1ceNate Begeman RHS = EI->getVectorOperand(); 8770533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8780533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8790533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (!Args.empty()) { 8800533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 8810533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(LHS, RHS, Mask); 8820533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8830533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8840533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8850533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8860533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 88777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 8880533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 8890533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = false; 8900533b3020ca39898751d4200feed776861dcd1ceNate Begeman ++CurIdx; 8910533b3020ca39898751d4200feed776861dcd1ceNate Begeman continue; 8920533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 8930533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8940533b3020ca39898751d4200feed776861dcd1ceNate Begeman unsigned InitElts = VVT->getNumElements(); 8950533b3020ca39898751d4200feed776861dcd1ceNate Begeman 8960533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the initializer is an ExtVecEltExpr (a swizzle), and the swizzle's 8970533b3020ca39898751d4200feed776861dcd1ceNate Begeman // input is the same width as the vector being constructed, generate an 8980533b3020ca39898751d4200feed776861dcd1ceNate Begeman // optimized shuffle of the swizzle input into the result. 899a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman unsigned Offset = (CurIdx == 0) ? 0 : ResElts; 9000533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (isa<ExtVectorElementExpr>(IE)) { 9010533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::ShuffleVectorInst *SVI = cast<llvm::ShuffleVectorInst>(Init); 9020533b3020ca39898751d4200feed776861dcd1ceNate Begeman Value *SVOp = SVI->getOperand(0); 9030533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::VectorType *OpTy = cast<llvm::VectorType>(SVOp->getType()); 9040533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9050533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (OpTy->getNumElements() == ResElts) { 9060533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) { 9070533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If the current vector initializer is a shuffle with undef, merge 9080533b3020ca39898751d4200feed776861dcd1ceNate Begeman // this shuffle directly into it. 9090533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) { 9100533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.push_back(getMaskElt(cast<llvm::ShuffleVectorInst>(V), j, 0, 91177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner CGF.Int32Ty)); 9120533b3020ca39898751d4200feed776861dcd1ceNate Begeman } else { 91377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 9140533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9150533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9160533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0, je = InitElts; j != je; ++j) 91777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(getMaskElt(SVI, j, Offset, CGF.Int32Ty)); 9180533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 91977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9200533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9210533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (VIsUndefShuffle) 9220533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = cast<llvm::ShuffleVectorInst>(V)->getOperand(0); 9230533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9240533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = SVOp; 9250533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9260533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9270533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9280533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Extend init to result vector length, and then shuffle its contribution 9290533b3020ca39898751d4200feed776861dcd1ceNate Begeman // to the vector initializer into V. 9300533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (Args.empty()) { 9310533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 93277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 9330533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = InitElts; j != ResElts; ++j) 93477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9350533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 9360533b3020ca39898751d4200feed776861dcd1ceNate Begeman Init = Builder.CreateShuffleVector(Init, llvm::UndefValue::get(VVT), 937a99f08351b6df3bb0f2947e038747717a60fd93aNate Begeman Mask, "vext"); 9380533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9390533b3020ca39898751d4200feed776861dcd1ceNate Begeman Args.clear(); 9400533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != CurIdx; ++j) 94177b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j)); 9420533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = 0; j != InitElts; ++j) 94377b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::ConstantInt::get(CGF.Int32Ty, j+Offset)); 9440533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (unsigned j = CurIdx + InitElts; j != ResElts; ++j) 94577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Args.push_back(llvm::UndefValue::get(CGF.Int32Ty)); 9460533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9470533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9480533b3020ca39898751d4200feed776861dcd1ceNate Begeman // If V is undef, make sure it ends up on the RHS of the shuffle to aid 9490533b3020ca39898751d4200feed776861dcd1ceNate Begeman // merging subsequent shuffles into this one. 9500533b3020ca39898751d4200feed776861dcd1ceNate Begeman if (CurIdx == 0) 9510533b3020ca39898751d4200feed776861dcd1ceNate Begeman std::swap(V, Init); 9520533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], ResElts); 9530533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateShuffleVector(V, Init, Mask, "vecinit"); 9540533b3020ca39898751d4200feed776861dcd1ceNate Begeman VIsUndefShuffle = isa<llvm::UndefValue>(Init); 9550533b3020ca39898751d4200feed776861dcd1ceNate Begeman CurIdx += InitElts; 9560533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9570533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9580533b3020ca39898751d4200feed776861dcd1ceNate Begeman // FIXME: evaluate codegen vs. shuffling against constant null vector. 9590533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers. 9600533b3020ca39898751d4200feed776861dcd1ceNate Begeman const llvm::Type *EltTy = VType->getElementType(); 9610533b3020ca39898751d4200feed776861dcd1ceNate Begeman 9620533b3020ca39898751d4200feed776861dcd1ceNate Begeman // Emit remaining default initializers 9630533b3020ca39898751d4200feed776861dcd1ceNate Begeman for (/* Do not initialize i*/; CurIdx < ResElts; ++CurIdx) { 96477b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, CurIdx); 9650533b3020ca39898751d4200feed776861dcd1ceNate Begeman llvm::Value *Init = llvm::Constant::getNullValue(EltTy); 9660533b3020ca39898751d4200feed776861dcd1ceNate Begeman V = Builder.CreateInsertElement(V, Init, Idx, "vecinit"); 9670533b3020ca39898751d4200feed776861dcd1ceNate Begeman } 9680533b3020ca39898751d4200feed776861dcd1ceNate Begeman return V; 9690533b3020ca39898751d4200feed776861dcd1ceNate Begeman} 9700533b3020ca39898751d4200feed776861dcd1ceNate Begeman 971a3697c9c155bda93fd2802f37084b620f4738822Anders Carlssonstatic bool ShouldNullCheckClassCastValue(const CastExpr *CE) { 972a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const Expr *E = CE->getSubExpr(); 97323cba801e11b03929c44f8cf54578305963a3476John McCall 9742de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (CE->getCastKind() == CK_UncheckedDerivedToBase) 97523cba801e11b03929c44f8cf54578305963a3476John McCall return false; 976a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 977a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (isa<CXXThisExpr>(E)) { 978a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson // We always assume that 'this' is never null. 979a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 980a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 981a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 982a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson if (const ImplicitCastExpr *ICE = dyn_cast<ImplicitCastExpr>(CE)) { 983906082edf2aea1c6de2926f93a8d7121e49d2a54Sebastian Redl // And that glvalue casts are never null. 9845baba9d98364a3525d6afa15a04cdad82fd6dd30John McCall if (ICE->getValueKind() != VK_RValue) 985a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return false; 986a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 987a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 988a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson return true; 989a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson} 990a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 991504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// VisitCastExpr - Emit code for an explicit or implicit cast. Implicit casts 992504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// have to handle a more broad range of conversions than explicit casts, as they 993504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson// handle things like function to ptr-to-function decay etc. 994d888962cff03b543fbe9ac6051ec6addf5b993b4Eli FriedmanValue *ScalarExprEmitter::EmitCastExpr(CastExpr *CE) { 995d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Expr *E = CE->getSubExpr(); 996592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson QualType DestTy = CE->getType(); 9972de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CastKind Kind = CE->getCastKind(); 998592a2bbc1945358ab8ebf0d74c57f0b23c4434c0Anders Carlsson 999504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson if (!DestTy->isVoidType()) 1000504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson TestAndClearIgnoreResultAssign(); 1001db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10028c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // Since almost all cast kinds apply to scalars, this switch doesn't have 10038c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // a default case, so the compiler will warn on a missing case. The cases 10048c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman // are in the same order as in the CastKind enum. 1005504bf55195ccbf84e016a0c7759669dee2975ba3Anders Carlsson switch (Kind) { 1006daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!"); 1007daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 10082de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_LValueBitCast: 10092de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ObjCObjectLValueCast: { 1010e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor Value *V = EmitLValue(E).getAddress(); 1011e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor V = Builder.CreateBitCast(V, 1012e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor ConvertType(CGF.getContext().getPointerType(DestTy))); 10139f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), DestTy); 1014e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor } 1015e39a3894513349908cdb3beba2614e53cb288e6cDouglas Gregor 10162de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_AnyPointerToObjCPointerCast: 10172de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_AnyPointerToBlockPointerCast: 10182de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BitCast: { 1019cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 1020cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson return Builder.CreateBitCast(Src, ConvertType(DestTy)); 1021cb3c308ef0e63b2902911b985517309c26f975dcAnders Carlsson } 10222de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NoOp: 10232de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UserDefinedConversion: 1024ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Visit(const_cast<Expr*>(E)); 1025db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 10262de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerived: { 1027a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson const CXXRecordDecl *DerivedClassDecl = 1028a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson DestTy->getCXXRecordDeclForPointerType(); 1029a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson 1030a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson return CGF.GetAddressOfDerivedClass(Visit(E), DerivedClassDecl, 1031f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 1032a04efdf635d35d88e65041fad007225d8c8d64a5Anders Carlsson ShouldNullCheckClassCastValue(CE)); 1033a3697c9c155bda93fd2802f37084b620f4738822Anders Carlsson } 10342de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_UncheckedDerivedToBase: 10352de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBase: { 1036191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson const RecordType *DerivedClassTy = 1037191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson E->getType()->getAs<PointerType>()->getPointeeType()->getAs<RecordType>(); 1038191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson CXXRecordDecl *DerivedClassDecl = 1039191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson cast<CXXRecordDecl>(DerivedClassTy->getDecl()); 1040191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 104134a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson return CGF.GetAddressOfBaseClass(Visit(E), DerivedClassDecl, 1042f871d0cc377a1367b519a6cce26be74607566ebaJohn McCall CE->path_begin(), CE->path_end(), 104334a2d384c745ebc39cae45dc1c0c4a6a7012e09bAnders Carlsson ShouldNullCheckClassCastValue(CE)); 1044191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson } 10452de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_Dynamic: { 10468c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman Value *V = Visit(const_cast<Expr*>(E)); 10478c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman const CXXDynamicCastExpr *DCE = cast<CXXDynamicCastExpr>(CE); 10488c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman return CGF.EmitDynamicCast(V, DCE); 10498c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman } 1050d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman 10512de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ArrayToPointerDecay: { 1052ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(E->getType()->isArrayType() && 1053ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Array to pointer decay must have array source type!"); 1054ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1055ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *V = EmitLValue(E).getAddress(); // Bitfields can't be arrays. 1056ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1057ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Note that VLA pointers are always decayed, so we don't need to do 1058ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // anything here. 1059ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman if (!E->getType()->isVariableArrayType()) { 1060ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::PointerType>(V->getType()) && "Expected pointer"); 1061ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman assert(isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType()) 1062ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman ->getElementType()) && 1063ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman "Expected pointer to array"); 1064ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman V = Builder.CreateStructGEP(V, 0, "arraydecay"); 1065ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1066ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1067ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return V; 1068ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 10692de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FunctionToPointerDecay: 1070ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return EmitLValue(E).getAddress(); 1071ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1072404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall case CK_NullToPointer: 1073404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall if (MustVisitNullValue(E)) 1074404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall (void) Visit(E); 1075404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 1076404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall return llvm::ConstantPointerNull::get( 1077404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall cast<llvm::PointerType>(ConvertType(DestTy))); 1078404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall 10792de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_NullToMemberPointer: { 1080404cd1669c3ba138a9ae0a619bd689cce5aae271John McCall if (MustVisitNullValue(E)) 1081d608cdb7c044365cf4e8764ade1e11e99c176078John McCall (void) Visit(E); 1082d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 10830bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = CE->getType()->getAs<MemberPointerType>(); 10840bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitNullMemberPointer(MPT); 10850bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 1086191dfe909d6cc18e9134ac23ac4daaedeceb862fAnders Carlsson 10872de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_BaseToDerivedMemberPointer: 10882de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_DerivedToBaseMemberPointer: { 1089d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman Value *Src = Visit(E); 1090d608cdb7c044365cf4e8764ade1e11e99c176078John McCall 1091d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // Note that the AST doesn't distinguish between checked and 1092d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // unchecked member pointer conversions, so we always have to 1093d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // implement checked conversions here. This is inefficient when 1094d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // actual control flow may be required in order to perform the 1095d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // check, which it is for data member pointers (but not member 1096d608cdb7c044365cf4e8764ade1e11e99c176078John McCall // function pointers on Itanium and ARM). 10970bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerConversion(CGF, CE, Src); 1098d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman } 10990bab0cdab751248ca389a5592bcb70eac5d39260John McCall 11002bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingRealToComplex: 11012bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_FloatingComplexCast: 11022bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralRealToComplex: 11032bb5d00fcf71a7b4d478d478be778fff0494aff6John McCall case CK_IntegralComplexCast: 1104f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToFloatingComplex: 1105f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToIntegralComplex: 11062de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ConstructorConversion: 110761ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall case CK_ToUnion: 110861ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall llvm_unreachable("scalar cast to non-scalar value"); 11098c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman break; 1110f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall 1111f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall case CK_GetObjCProperty: { 1112f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)); 1113f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(E->isLValue() && E->getObjectKind() == OK_ObjCProperty && 1114f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall "CK_GetObjCProperty for non-lvalue or non-ObjCProperty"); 1115f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall RValue RV = CGF.EmitLoadOfLValue(CGF.EmitLValue(E), E->getType()); 1116f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall return RV.getScalarVal(); 1117f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall } 11180ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall 11190ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall case CK_LValueToRValue: 11200ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall assert(CGF.getContext().hasSameUnqualifiedType(E->getType(), DestTy)); 1121f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall assert(E->isGLValue() && "lvalue-to-rvalue applied to r-value!"); 11220ae287a498b8cec2086fe6b7e753cbb3df63e74aJohn McCall return Visit(const_cast<Expr*>(E)); 11238c3e7e7ddafe26f236741fb25e2898be4f3230eaEli Friedman 11242de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToPointer: { 11257f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 112689f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 112782debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // First, convert to the correct width so that we control the kind of 112882debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson // extension. 112977b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *MiddleTy = CGF.IntPtrTy; 113082debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson bool InputSigned = E->getType()->isSignedIntegerType(); 113182debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson llvm::Value* IntResult = 113282debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson Builder.CreateIntCast(Src, MiddleTy, InputSigned, "conv"); 113389f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 113482debc7d282e723e58d183bfa89ddc2500a8daafAnders Carlsson return Builder.CreateIntToPtr(IntResult, ConvertType(DestTy)); 11357f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 11362de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_PointerToIntegral: { 11377f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson Value *Src = Visit(const_cast<Expr*>(E)); 113889f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 113989f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar // Handle conversion to bool correctly. 114089f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar if (DestTy->isBooleanType()) 1141db50547fd526329d00fa1fee4e7ac90f2624c6e0Daniel Dunbar return EmitScalarConversion(Src, E->getType(), DestTy); 114289f176d89aefe8a23bbf0ace9b329562f4970d5fDaniel Dunbar 11437f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson return Builder.CreatePtrToInt(Src, ConvertType(DestTy)); 11447f9e646b7ed47bc8e9a60031ad0c2b55031e2077Anders Carlsson } 11452de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_ToVoid: { 11462a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E); 1147ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return 0; 1148ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 11492de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_VectorSplat: { 1150ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman const llvm::Type *DstTy = ConvertType(DestTy); 1151ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman Value *Elt = Visit(const_cast<Expr*>(E)); 1152ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1153ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Insert the element in element zero of an undef vector 1154ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *UnV = llvm::UndefValue::get(DstTy); 115577b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Value *Idx = llvm::ConstantInt::get(CGF.Int32Ty, 0); 1156ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman UnV = Builder.CreateInsertElement(UnV, Elt, Idx, "tmp"); 1157ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1158ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman // Splat the element across to all elements 1159ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::SmallVector<llvm::Constant*, 16> Args; 1160ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman unsigned NumElements = cast<llvm::VectorType>(DstTy)->getNumElements(); 1161daa8e4e888758d55a7a759dd4a91b83921cef222John McCall llvm::Constant *Zero = llvm::ConstantInt::get(CGF.Int32Ty, 0); 1162ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman for (unsigned i = 0; i < NumElements; i++) 1163daa8e4e888758d55a7a759dd4a91b83921cef222John McCall Args.push_back(Zero); 1164ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1165ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements); 1166ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman llvm::Value *Yay = Builder.CreateShuffleVector(UnV, UnV, Mask, "splat"); 1167ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman return Yay; 1168ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman } 1169daa8e4e888758d55a7a759dd4a91b83921cef222John McCall 11702de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralCast: 11712de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_IntegralToFloating: 11722de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingToIntegral: 11732de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_FloatingCast: 1174d888962cff03b543fbe9ac6051ec6addf5b993b4Eli Friedman return EmitScalarConversion(Visit(E), E->getType(), DestTy); 1175ad35a83102683b00a7e28707eee7f2d8c994b742Eli Friedman 1176daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_IntegralToBoolean: 1177daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitIntToBoolConversion(Visit(E)); 1178daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_PointerToBoolean: 1179daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitPointerToBoolConversion(Visit(E)); 1180daa8e4e888758d55a7a759dd4a91b83921cef222John McCall case CK_FloatingToBoolean: 1181daa8e4e888758d55a7a759dd4a91b83921cef222John McCall return EmitFloatToBoolConversion(Visit(E)); 11822de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case CK_MemberPointerToBoolean: { 11830bab0cdab751248ca389a5592bcb70eac5d39260John McCall llvm::Value *MemPtr = Visit(E); 11840bab0cdab751248ca389a5592bcb70eac5d39260John McCall const MemberPointerType *MPT = E->getType()->getAs<MemberPointerType>(); 11850bab0cdab751248ca389a5592bcb70eac5d39260John McCall return CGF.CGM.getCXXABI().EmitMemberPointerIsNotNull(CGF, MemPtr, MPT); 1186e9776247577715ad3a19461769a3488a445a8cbdAnders Carlsson } 1187f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1188f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToReal: 1189f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToReal: 1190b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(E, false, true).first; 1191f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1192f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_FloatingComplexToBoolean: 1193f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall case CK_IntegralComplexToBoolean: { 1194b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall CodeGenFunction::ComplexPairTy V = CGF.EmitComplexExpr(E); 1195f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 1196f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall // TODO: kill this function off, inline appropriate case here 1197f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall return EmitComplexToScalarConversion(V, E->getType(), DestTy); 1198f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall } 1199f3ea8cfe6b1c2ef0702efe130561e9e66708d799John McCall 12000bab0cdab751248ca389a5592bcb70eac5d39260John McCall } 120110b00cfe6422906b223724048b9b2123968d3baaChris Lattner 120261ad0e6f40555a6bf589cbc7849c25f2b35efae4John McCall llvm_unreachable("unknown scalar cast"); 120319a1d7c646729eb858b15583e647262a22de3637Chris Lattner return 0; 12047f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 12057f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12063379320c10001d7e1ee5d7e7142c417f797cfe82Chris LattnerValue *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) { 12078d3d6c93551cc62c6d550f090991bfba1d32d0a4John McCall RValue value = CGF.EmitCompoundStmt(*E->getSubStmt(), 12088d3d6c93551cc62c6d550f090991bfba1d32d0a4John McCall !E->getType()->isVoidType()); 12098d3d6c93551cc62c6d550f090991bfba1d32d0a4John McCall CGF.EnsureInsertPoint(); 12108d3d6c93551cc62c6d550f090991bfba1d32d0a4John McCall return value.getScalarVal(); 12113379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner} 12123379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 1213a99038c0757a836c6faeeddaa5dfd249b32f6e9eMike StumpValue *ScalarExprEmitter::VisitBlockDeclRefExpr(const BlockDeclRefExpr *E) { 1214f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian llvm::Value *V = CGF.GetAddrOfBlockDecl(E); 1215f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian if (E->getType().isObjCGCWeak()) 1216f7bcc7e6c803a2b2f7b7f7fdfb2506dd25ec6de8Fariborz Jahanian return CGF.CGM.getObjCRuntime().EmitObjCWeakRead(CGF, V); 1217469a20de757ff872c90ff6b1134f6346909ff652Fariborz Jahanian return CGF.EmitLoadOfScalar(V, false, 0, E->getType()); 12184e7a1f7682d94811bd41fca8aefccc38f686db23Mike Stump} 12193379320c10001d7e1ee5d7e7142c417f797cfe82Chris Lattner 12207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Unary Operators 12227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 12237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 12248c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *ScalarExprEmitter:: 12258c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 12268c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 12278c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12288c11a65c18ae607b7073e1e451264492d2297726Chris Lattner QualType ValTy = E->getSubExpr()->getType(); 12298c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *InVal = EmitLoadOfLValue(LV, ValTy); 12308c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12318c11a65c18ae607b7073e1e451264492d2297726Chris Lattner int AmountVal = isInc ? 1 : -1; 12328c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12338c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (ValTy->isPointerType() && 12348c11a65c18ae607b7073e1e451264492d2297726Chris Lattner ValTy->getAs<PointerType>()->isVariableArrayType()) { 12358c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // The amount of the addition/subtraction needs to account for the VLA size 12368c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.ErrorUnsupported(E, "VLA pointer inc/dec"); 12378c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 12388c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 12398c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *NextVal; 12408c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (const llvm::PointerType *PT = 12418c11a65c18ae607b7073e1e451264492d2297726Chris Lattner dyn_cast<llvm::PointerType>(InVal->getType())) { 124277b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner llvm::Constant *Inc = llvm::ConstantInt::get(CGF.Int32Ty, AmountVal); 12438c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (!isa<llvm::FunctionType>(PT->getElementType())) { 12448c11a65c18ae607b7073e1e451264492d2297726Chris Lattner QualType PTEE = ValTy->getPointeeType(); 12458c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (const ObjCObjectType *OIT = PTEE->getAs<ObjCObjectType>()) { 12468c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Handle interface types, which are not represented with a concrete 12478c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // type. 1248fe71008c2764768f25478b16c1802755189ed7c9Ken Dyck CharUnits size = CGF.getContext().getTypeSizeInChars(OIT); 12498c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (!isInc) 12508c11a65c18ae607b7073e1e451264492d2297726Chris Lattner size = -size; 1251fe71008c2764768f25478b16c1802755189ed7c9Ken Dyck Inc = llvm::ConstantInt::get(Inc->getType(), size.getQuantity()); 12528c11a65c18ae607b7073e1e451264492d2297726Chris Lattner const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 12538c11a65c18ae607b7073e1e451264492d2297726Chris Lattner InVal = Builder.CreateBitCast(InVal, i8Ty); 12548c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateGEP(InVal, Inc, "add.ptr"); 12558c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::Value *lhs = LV.getAddress(); 12568c11a65c18ae607b7073e1e451264492d2297726Chris Lattner lhs = Builder.CreateBitCast(lhs, llvm::PointerType::getUnqual(i8Ty)); 12579f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar LV = CGF.MakeAddrLValue(lhs, ValTy); 12588c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else 12598c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateInBoundsGEP(InVal, Inc, "ptrincdec"); 12608c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 12618c11a65c18ae607b7073e1e451264492d2297726Chris Lattner const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 12628c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateBitCast(InVal, i8Ty, "tmp"); 12638c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateGEP(NextVal, Inc, "ptrincdec"); 12648c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateBitCast(NextVal, InVal->getType()); 12658c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 12668c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else if (InVal->getType()->isIntegerTy(1) && isInc) { 12678c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool++ is an interesting case, due to promotion rules, we get: 12688c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool++ -> Bool = Bool+1 -> Bool = (int)Bool+1 -> 12698c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Bool = ((int)Bool+1) != 0 12708c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // An interesting aspect of this is that increment is always true. 12718c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Decrement does not have this property. 12728c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantInt::getTrue(VMContext); 12738c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else if (isa<llvm::IntegerType>(InVal->getType())) { 12748c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal); 12758c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 1276640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner if (!ValTy->isSignedIntegerType()) 1277640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner // Unsigned integer inc is always two's complement. 12788c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1279640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner else { 1280640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1281640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Undefined: 1282640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner NextVal = Builder.CreateNSWAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1283640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner break; 1284640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Defined: 1285640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec"); 1286640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner break; 1287640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner case LangOptions::SOB_Trapping: 1288640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOpInfo BinOp; 1289640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.LHS = InVal; 1290640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.RHS = NextVal; 1291640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.Ty = E->getType(); 12922de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall BinOp.Opcode = BO_Add; 1293640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner BinOp.E = E; 1294401be6bddcf05ac2828730e0bb4e8b81931f8296John McCall NextVal = EmitOverflowCheckedBinOp(BinOp); 1295401be6bddcf05ac2828730e0bb4e8b81931f8296John McCall break; 1296640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner } 1297640d3267228415328c0feb2bcc35757230ab4db7Chris Lattner } 12988c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } else { 12998c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Add the inc/dec to the real part. 13008c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (InVal->getType()->isFloatTy()) 13018c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = 13028c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::ConstantFP::get(VMContext, 13038c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat(static_cast<float>(AmountVal))); 13048c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else if (InVal->getType()->isDoubleTy()) 13058c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = 13068c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::ConstantFP::get(VMContext, 13078c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat(static_cast<double>(AmountVal))); 13088c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else { 13098c11a65c18ae607b7073e1e451264492d2297726Chris Lattner llvm::APFloat F(static_cast<float>(AmountVal)); 13108c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool ignored; 13118c11a65c18ae607b7073e1e451264492d2297726Chris Lattner F.convert(CGF.Target.getLongDoubleFormat(), llvm::APFloat::rmTowardZero, 13128c11a65c18ae607b7073e1e451264492d2297726Chris Lattner &ignored); 13138c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = llvm::ConstantFP::get(VMContext, F); 13148c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 13158c11a65c18ae607b7073e1e451264492d2297726Chris Lattner NextVal = Builder.CreateFAdd(InVal, NextVal, isInc ? "inc" : "dec"); 13168c11a65c18ae607b7073e1e451264492d2297726Chris Lattner } 13178c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13188c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // Store the updated result through the lvalue. 13198c11a65c18ae607b7073e1e451264492d2297726Chris Lattner if (LV.isBitField()) 13208c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.EmitStoreThroughBitfieldLValue(RValue::get(NextVal), LV, ValTy, &NextVal); 13218c11a65c18ae607b7073e1e451264492d2297726Chris Lattner else 13228c11a65c18ae607b7073e1e451264492d2297726Chris Lattner CGF.EmitStoreThroughLValue(RValue::get(NextVal), LV, ValTy); 13238c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13248c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // If this is a postinc, return the value read from memory, otherwise use the 13258c11a65c18ae607b7073e1e451264492d2297726Chris Lattner // updated value. 13268c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return isPre ? NextVal : InVal; 13278c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 13288c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13298c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13308c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 13317f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 13327f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 13339a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Emit unary minus with EmitSub so we handle overflow cases etc. 13349a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOpInfo BinOp; 13354ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.RHS = Visit(E->getSubExpr()); 13364ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner 13374ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner if (BinOp.RHS->getType()->isFPOrFPVectorTy()) 13384ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::ConstantFP::getZeroValueForNegation(BinOp.RHS->getType()); 13394ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner else 13404ac0d83090c750bd8ab2c4fc91a6a44c32884cb3Chris Lattner BinOp.LHS = llvm::Constant::getNullValue(BinOp.RHS->getType()); 13419a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.Ty = E->getType(); 13422de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall BinOp.Opcode = BO_Sub; 13439a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp.E = E; 13449a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner return EmitSub(BinOp); 13457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 13487f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 13497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *Op = Visit(E->getSubExpr()); 13507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateNot(Op, "neg"); 13517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) { 13547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Compare operand to zero. 13557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr()); 1356db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 13577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Invert value. 13587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // TODO: Could dynamically modify easy computations here. For example, if 13597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // the operand is an icmp ne, turn into icmp eq. 13607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BoolVal = Builder.CreateNot(BoolVal, "lnot"); 1361db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 13629f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson // ZExt result to the expr type. 13639f84d88a302ea38cf0695ce8cdace47178d2fff4Anders Carlsson return Builder.CreateZExt(BoolVal, ConvertType(E->getType()), "lnot.ext"); 13647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 13657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 13660027d2bb24db629a33a71d04a5fb90a14c15a680Eli FriedmanValue *ScalarExprEmitter::VisitOffsetOfExpr(OffsetOfExpr *E) { 13670027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Try folding the offsetof to a constant. 13680027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr::EvalResult EvalResult; 13690027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (E->Evaluate(EvalResult, CGF.getContext())) 13700027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman return llvm::ConstantInt::get(VMContext, EvalResult.Val.getInt()); 13710027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13720027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Loop over the components of the offsetof to compute the value. 13730027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned n = E->getNumComponents(); 13740027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const llvm::Type* ResultType = ConvertType(E->getType()); 13750027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Result = llvm::Constant::getNullValue(ResultType); 13760027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman QualType CurrentType = E->getTypeSourceInfo()->getType(); 13770027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (unsigned i = 0; i != n; ++i) { 13780027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman OffsetOfExpr::OffsetOfNode ON = E->getComponent(i); 137916fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman llvm::Value *Offset = 0; 13800027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman switch (ON.getKind()) { 13810027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Array: { 13820027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index 13830027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Expr *IdxExpr = E->getIndexExpr(ON.getArrayExprIndex()); 13840027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* Idx = CGF.EmitScalarExpr(IdxExpr); 13850027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman bool IdxSigned = IdxExpr->getType()->isSignedIntegerType(); 13860027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Idx = Builder.CreateIntCast(Idx, ResultType, IdxSigned, "conv"); 13870027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13880027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type 13890027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = 13900027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getAsArrayType(CurrentType)->getElementType(); 13910027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13920027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the element size 13930027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman llvm::Value* ElemSize = llvm::ConstantInt::get(ResultType, 13940027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getTypeSizeInChars(CurrentType).getQuantity()); 13950027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 13960027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Multiply out to compute the result 13970027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = Builder.CreateMul(Idx, ElemSize); 13980027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 13990027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14000027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14010027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Field: { 14020027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldDecl *MemberDecl = ON.getField(); 14030027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 14040027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 14050027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14060027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the index of the field in its parent. 14070027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman unsigned i = 0; 14080027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // FIXME: It would be nice if we didn't have to loop here! 14090027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman for (RecordDecl::field_iterator Field = RD->field_begin(), 14100027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman FieldEnd = RD->field_end(); 14110027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Field != FieldEnd; (void)++Field, ++i) { 14120027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (*Field == MemberDecl) 14130027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14140027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14150027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman assert(i < RL.getFieldCount() && "offsetof field in wrong type"); 14160027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14170027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the field 14180027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman int64_t OffsetInt = RL.getFieldOffset(i) / 14190027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 14200027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 14210027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14220027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 14230027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = MemberDecl->getType(); 14240027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14250027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 142616fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 14270027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Identifier: 14286d4e44b462fe9e870a40358522379400ccc6e3c2Eli Friedman llvm_unreachable("dependent __builtin_offsetof"); 142916fd39fb11cce33d58ecdd39f25540b85c1542b4Eli Friedman 14300027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman case OffsetOfExpr::OffsetOfNode::Base: { 14310027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman if (ON.getBase()->isVirtual()) { 14320027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.ErrorUnsupported(E, "virtual base in offsetof"); 14330027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman continue; 14340027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14350027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14360027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman RecordDecl *RD = CurrentType->getAs<RecordType>()->getDecl(); 14370027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const ASTRecordLayout &RL = CGF.getContext().getASTRecordLayout(RD); 14380027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14390027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Save the element type. 14400027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CurrentType = ON.getBase()->getType(); 14410027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman 14420027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman // Compute the offset to the base. 14430027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman const RecordType *BaseRT = CurrentType->getAs<RecordType>(); 14440027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CXXRecordDecl *BaseRD = cast<CXXRecordDecl>(BaseRT->getDecl()); 1445a14f5979572aa25c03d24750ee4724d2031d4edeAnders Carlsson int64_t OffsetInt = RL.getBaseClassOffsetInBits(BaseRD) / 14460027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman CGF.getContext().getCharWidth(); 14470027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Offset = llvm::ConstantInt::get(ResultType, OffsetInt); 14480027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman break; 14490027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14500027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14510027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman Result = Builder.CreateAdd(Result, Offset); 14520027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman } 14530027d2bb24db629a33a71d04a5fb90a14c15a680Eli Friedman return Result; 14548ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor} 14558ecdb65716cd7914ffb2eeee993fa9039fcd31e8Douglas Gregor 14560518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// VisitSizeOfAlignOfExpr - Return the size or alignment of the type of 14570518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl/// argument of the sizeof expression as an integer. 14580518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlValue * 14590518999d3adcc289997bd974dce90cc97f5c1c44Sebastian RedlScalarExprEmitter::VisitSizeOfAlignOfExpr(const SizeOfAlignOfExpr *E) { 14600518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl QualType TypeToSize = E->getTypeOfArgument(); 1461f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isSizeOf()) { 1462db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (const VariableArrayType *VAT = 1463f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.getContext().getAsVariableArrayType(TypeToSize)) { 1464f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman if (E->isArgumentType()) { 1465f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman // sizeof(type) - make sure to emit the VLA size. 1466f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman CGF.EmitVLASize(TypeToSize); 14678f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman } else { 14688f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // C99 6.5.3.4p2: If the argument is an expression of type 14698f426fa9fca022201fc0944d6c1cb2cf9918db7dEli Friedman // VLA, it is evaluated. 14702a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E->getArgumentExpr()); 1471f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman } 1472db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 147396f214776c0f69069fee4d67557c8c7f416009a8Anders Carlsson return CGF.GetVLASize(VAT); 1474b50525ba0e996bc072cdb76152fcfe0bc64bb72aAnders Carlsson } 14755d46315ca3cbbfe0d0f5f65520b618fb05dd4446Anders Carlsson } 1476f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman 1477db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If this isn't sizeof(vla), the result must be constant; use the constant 1478db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // folding logic so we don't have to duplicate it here. 1479f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman Expr::EvalResult Result; 1480f2da9dfef96dc11b7b5effb1d02cb427b2d71599Eli Friedman E->Evaluate(Result, CGF.getContext()); 14814a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson return llvm::ConstantInt::get(VMContext, Result.Val.getInt()); 14827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 14837f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 148446f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) { 148546f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 1486b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (Op->getType()->isAnyComplexType()) { 1487b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If it's an l-value, load through the appropriate subobject l-value. 1488b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Note that we have to ask E because Op might be an l-value that 1489b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // this won't work for, e.g. an Obj-C property. 14907eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (E->isGLValue()) 1491b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitLoadOfLValue(CGF.EmitLValue(E), E->getType()) 1492b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall .getScalarVal(); 1493b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1494b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Otherwise, calculate and project. 1495b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(Op, false, true).first; 1496b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall } 1497b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 149846f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner return Visit(Op); 149946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 1500b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 150146f93d021a1778442c1c4a53f0b94a68bfae3be5Chris LattnerValue *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) { 150246f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner Expr *Op = E->getSubExpr(); 1503b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (Op->getType()->isAnyComplexType()) { 1504b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If it's an l-value, load through the appropriate subobject l-value. 1505b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Note that we have to ask E because Op might be an l-value that 1506b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // this won't work for, e.g. an Obj-C property. 15077eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (Op->isGLValue()) 1508b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitLoadOfLValue(CGF.EmitLValue(E), E->getType()) 1509b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall .getScalarVal(); 1510b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1511b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // Otherwise, calculate and project. 1512b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return CGF.EmitComplexExpr(Op, true, false).second; 1513b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall } 1514db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 15157f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __imag on a scalar returns zero. Emit the subexpr to ensure side 15167f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // effects are evaluated, but not the actual value. 1517b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall CGF.EmitScalarExpr(Op, true); 1518c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson return llvm::Constant::getNullValue(ConvertType(E->getType())); 151946f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner} 152046f93d021a1778442c1c4a53f0b94a68bfae3be5Chris Lattner 15217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 15227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Binary Operators 15237f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 15247f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerBinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) { 15267f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 15277f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner BinOpInfo Result; 15287f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.LHS = Visit(E->getLHS()); 15297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.RHS = Visit(E->getRHS()); 15301f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner Result.Ty = E->getType(); 15319a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner Result.Opcode = E->getOpcode(); 15327f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result.E = E; 15337f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Result; 15347f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 15357f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 15366a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorLValue ScalarExprEmitter::EmitCompoundAssignLValue( 15376a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E, 15386a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &), 1539d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *&Result) { 154054d76db0aa7107597cac0b80d8e138a37e6d1de9Benjamin Kramer QualType LHSTy = E->getLHS()->getType(); 15411f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner BinOpInfo OpInfo; 15426a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1543ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman if (E->getComputationResultType()->isAnyComplexType()) { 1544db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // This needs to go through the complex expression emitter, but it's a tad 1545db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // complicated to do that... I'm leaving it out for now. (Note that we do 1546db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // actually need the imaginary part of the RHS for multiplication and 1547db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // division.) 1548ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman CGF.ErrorUnsupported(E, "complex compound assignment"); 1549d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = llvm::UndefValue::get(CGF.ConvertType(E->getType())); 15506a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LValue(); 15511f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner } 15526a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1553cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // Emit the RHS first. __block variables need to have the rhs evaluated 1554cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump // first, plus this should improve codegen a little. 1555cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.RHS = Visit(E->getRHS()); 1556cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.Ty = E->getComputationResultType(); 15579a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OpInfo.Opcode = E->getOpcode(); 1558cc0442fa28e5d1f403f820dcdee49911c3e622a9Mike Stump OpInfo.E = E; 1559ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman // Load/convert the LHS. 1560b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHSLV = EmitCheckedLValue(E->getLHS()); 1561ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy); 1562ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, 1563ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman E->getComputationLHSType()); 15646a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 15651f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner // Expand the binary operator. 1566d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result = (this->*Func)(OpInfo); 15676a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 15688c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Convert the result back to the LHS type. 1569ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman Result = EmitScalarConversion(Result, E->getComputationResultType(), LHSTy); 15706a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 1571db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Store the result value into the LHS lvalue. Bit-fields are handled 1572db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // specially because the result is altered by the store, i.e., [C99 6.5.16p1] 1573db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // 'An assignment expression has the value of the left operand after the 1574db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // assignment...'. 1575d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHSLV.isBitField()) 1576d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(Result), LHSLV, LHSTy, 1577d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar &Result); 1578d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 1579ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, LHSTy); 1580d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 15816a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return LHSLV; 15826a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 15836a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 15846a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas GregorValue *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E, 15856a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) { 15866a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor bool Ignore = TestAndClearIgnoreResultAssign(); 1587d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *RHS; 1588d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar LValue LHS = EmitCompoundAssignLValue(E, Func, RHS); 1589d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1590d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 15917f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 15927f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 1593d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1594b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 1595b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!CGF.getContext().getLangOptions().CPlusPlus) 1596b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return RHS; 1597b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 1598d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 1599119a1c6c4029d30cae7b31a2826aa0ff70d01668John McCall if (LHS.isPropertyRef()) 1600d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1601d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1602d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 1603d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 1604d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 1605d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 1606d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 1607d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return EmitLoadOfLValue(LHS, E->getType()); 16081f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner} 16091f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 16108023030f76d334355b73d9c675d3870858aaf4fdChris Lattnervoid ScalarExprEmitter::EmitUndefinedBehaviorIntegerDivAndRemCheck( 16118023030f76d334355b73d9c675d3870858aaf4fdChris Lattner const BinOpInfo &Ops, 16128023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero, bool isDiv) { 16138023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 16148023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *contBB = 16158023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.createBasicBlock(isDiv ? "div.cont" : "rem.cont", CGF.CurFn); 16168023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16178023030f76d334355b73d9c675d3870858aaf4fdChris Lattner const llvm::IntegerType *Ty = cast<llvm::IntegerType>(Zero->getType()); 16188023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16198023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->hasSignedIntegerRepresentation()) { 16208023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *IntMin = 16218023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::ConstantInt::get(VMContext, 16228023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::APInt::getSignedMinValue(Ty->getBitWidth())); 16238023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *NegOne = llvm::ConstantInt::get(Ty, -1ULL); 16248023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16258023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond1 = Builder.CreateICmpEQ(Ops.RHS, Zero); 16268023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *LHSCmp = Builder.CreateICmpEQ(Ops.LHS, IntMin); 16278023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *RHSCmp = Builder.CreateICmpEQ(Ops.RHS, NegOne); 16288023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Cond2 = Builder.CreateAnd(LHSCmp, RHSCmp, "and"); 16298023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.CreateCondBr(Builder.CreateOr(Cond1, Cond2, "or"), 16308023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 16318023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } else { 16328023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateICmpEQ(Ops.RHS, Zero), 16338023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, contBB); 16348023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 16358023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 16368023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(contBB); 16378023030f76d334355b73d9c675d3870858aaf4fdChris Lattner} 16381f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 16397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) { 16408023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 16418023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 16428023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16438023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 16448023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, true); 16458023030f76d334355b73d9c675d3870858aaf4fdChris Lattner else if (Ops.Ty->isRealFloatingType()) { 16468023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", 16478023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.CurFn); 16488023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::BasicBlock *DivCont = CGF.createBasicBlock("div.cont", CGF.CurFn); 16498023030f76d334355b73d9c675d3870858aaf4fdChris Lattner CGF.Builder.CreateCondBr(Builder.CreateFCmpOEQ(Ops.RHS, Zero), 16508023030f76d334355b73d9c675d3870858aaf4fdChris Lattner overflowBB, DivCont); 16518023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitOverflowBB(overflowBB); 16528023030f76d334355b73d9c675d3870858aaf4fdChris Lattner Builder.SetInsertPoint(DivCont); 16538023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 16548023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 1655f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 16567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div"); 1657f60946222721d9ba3c059563935c17b84703187aDouglas Gregor else if (Ops.Ty->hasUnsignedIntegerRepresentation()) 16587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div"); 16597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 16607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div"); 16617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 16627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) { 16647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Rem in C can't be a floating point type: C99 6.5.5p2. 16658023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (isTrapvOverflowBehavior()) { 16668023030f76d334355b73d9c675d3870858aaf4fdChris Lattner llvm::Value *Zero = llvm::Constant::getNullValue(ConvertType(Ops.Ty)); 16678023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16688023030f76d334355b73d9c675d3870858aaf4fdChris Lattner if (Ops.Ty->isIntegerType()) 16698023030f76d334355b73d9c675d3870858aaf4fdChris Lattner EmitUndefinedBehaviorIntegerDivAndRemCheck(Ops, Zero, false); 16708023030f76d334355b73d9c675d3870858aaf4fdChris Lattner } 16718023030f76d334355b73d9c675d3870858aaf4fdChris Lattner 16721f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner if (Ops.Ty->isUnsignedIntegerType()) 16737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem"); 16747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner else 16757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem"); 16767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 16777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 16782add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike StumpValue *ScalarExprEmitter::EmitOverflowCheckedBinOp(const BinOpInfo &Ops) { 16792add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned IID; 16802add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump unsigned OpID = 0; 16815d8b2cf9fd704f6ca5e33525803a65421c0b440eMike Stump 16829a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner switch (Ops.Opcode) { 16832de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 16842de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_AddAssign: 1685035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 1; 1686035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::sadd_with_overflow; 1687035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 16882de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 16892de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_SubAssign: 1690035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 2; 1691035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::ssub_with_overflow; 1692035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 16932de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 16942de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_MulAssign: 1695035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID = 3; 1696035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump IID = llvm::Intrinsic::smul_with_overflow; 1697035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump break; 1698035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump default: 1699035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump assert(false && "Unsupported operation for overflow detection"); 1700ab4eff620a9ce0ea62cdf29529a66c2c98d116f5Daniel Dunbar IID = 0; 1701035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump } 1702035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID <<= 1; 1703035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump OpID |= 1; 1704035cf8911c2282550411be70f370dfe5d282b5c9Mike Stump 17052add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump const llvm::Type *opTy = CGF.CGM.getTypes().ConvertType(Ops.Ty); 17062add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17072add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump llvm::Function *intrinsic = CGF.CGM.getIntrinsic(IID, &opTy, 1); 17082add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17092add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *resultAndOverflow = Builder.CreateCall2(intrinsic, Ops.LHS, Ops.RHS); 17102add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *result = Builder.CreateExtractValue(resultAndOverflow, 0); 17112add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Value *overflow = Builder.CreateExtractValue(resultAndOverflow, 1); 17122add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17132add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump // Branch in case of overflow. 17147f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::BasicBlock *initialBB = Builder.GetInsertBlock(); 171593a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *overflowBB = CGF.createBasicBlock("overflow", CGF.CurFn); 171693a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner llvm::BasicBlock *continueBB = CGF.createBasicBlock("nooverflow", CGF.CurFn); 17172add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 17182add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.CreateCondBr(overflow, overflowBB, continueBB); 17192add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump 172093a00357f2795404c6709d9e06b4f717c82e6efbChris Lattner // Handle overflow with llvm.trap. 17217f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall const std::string *handlerName = 17227f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall &CGF.getContext().getLangOptions().OverflowHandler; 17237f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall if (handlerName->empty()) { 17247f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall EmitOverflowBB(overflowBB); 17257f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(continueBB); 17267f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return result; 17277f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall } 17287f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17297f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // If an overflow handler is set, then we want to call it and then use its 17307f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // result, if it returns. 17317f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.SetInsertPoint(overflowBB); 17327f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17337f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Get the overflow handler. 17347f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall const llvm::Type *Int8Ty = llvm::Type::getInt8Ty(VMContext); 17357f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall std::vector<const llvm::Type*> argTypes; 17367f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall argTypes.push_back(CGF.Int64Ty); argTypes.push_back(CGF.Int64Ty); 17377f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall argTypes.push_back(Int8Ty); argTypes.push_back(Int8Ty); 17387f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType *handlerTy = 17397f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::FunctionType::get(CGF.Int64Ty, argTypes, true); 17407f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handler = CGF.CGM.CreateRuntimeFunction(handlerTy, *handlerName); 17417f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17427f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Sign extend the args to 64-bit, so that we can use the same handler for 17437f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // all types of overflow. 17447f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *lhs = Builder.CreateSExt(Ops.LHS, CGF.Int64Ty); 17457f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *rhs = Builder.CreateSExt(Ops.RHS, CGF.Int64Ty); 17467f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17477f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Call the handler with the two arguments, the operation, and the size of 17487f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // the result. 17497f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::Value *handlerResult = Builder.CreateCall4(handler, lhs, rhs, 17507f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(OpID), 17517f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.getInt8(cast<llvm::IntegerType>(opTy)->getBitWidth())); 17527f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17537f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall // Truncate the result back to the desired size. 17547f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall handlerResult = Builder.CreateTrunc(handlerResult, opTy); 17557f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall Builder.CreateBr(continueBB); 17567f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17572add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump Builder.SetInsertPoint(continueBB); 17587f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall llvm::PHINode *phi = Builder.CreatePHI(opTy); 17597f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->reserveOperandSpace(2); 17607f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(result, initialBB); 17617f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall phi->addIncoming(handlerResult, overflowBB); 17627f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall 17637f18e67e1b577a50402e8b43508ab2311a5c45b5David Chisnall return phi; 17642add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump} 17657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 17667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) { 176758f9f2c884af6b72d036b746a016d8031d31cb7aSteve Naroff if (!Ops.Ty->isAnyPointerType()) { 1768f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 1769a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1770a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1771a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWAdd(Ops.LHS, Ops.RHS, "add"); 1772a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1773a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 1774a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1775a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1776a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1777a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1778a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1779f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 178087415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFAdd(Ops.LHS, Ops.RHS, "add"); 1781bf933a0cb628670490c15367b3f5ccb3193354a7Dan Gohman 17827f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add"); 17832add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 1784daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 17857f215c12af4c3e7f81b24102a676aabfdb4e1566Chris Lattner // Must have binary (not unary) expr here. Unary pointer decrement doesn't 17869a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 17879a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 17889a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 178914108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (Ops.Ty->isPointerType() && 17906217b80b7a1379b74cced1c076338262c3c980b3Ted Kremenek Ops.Ty->getAs<PointerType>()->isVariableArrayType()) { 1791daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size 17929a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer addition"); 1793daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 17949a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 17958f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Value *Ptr, *Idx; 17968f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Expr *IdxExp; 17979a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const PointerType *PT = BinOp->getLHS()->getType()->getAs<PointerType>(); 1798db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump const ObjCObjectPointerType *OPT = 17999a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<ObjCObjectPointerType>(); 180014108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff if (PT || OPT) { 18018f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.LHS; 18028f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.RHS; 18039a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getRHS(); 180414108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff } else { // int + pointer 18059a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner PT = BinOp->getRHS()->getType()->getAs<PointerType>(); 18069a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner OPT = BinOp->getRHS()->getType()->getAs<ObjCObjectPointerType>(); 180714108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff assert((PT || OPT) && "Invalid add expr"); 18088f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Ptr = Ops.RHS; 18098f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Ops.LHS; 18109a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner IdxExp = BinOp->getLHS(); 18118f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 18128f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner 18138f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 18147cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 18158f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // Zero or sign extend the pointer value based on whether the index is 18168f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner // signed or not. 181777b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *IdxType = CGF.IntPtrTy; 18189619662a1d42e2008b865d3459c0677e149dad1bChris Lattner if (IdxExp->getType()->isSignedIntegerType()) 18198f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 18208f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner else 18218f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 18228f925280abe3795ae0fb47f2ba90faea62e26af4Chris Lattner } 182314108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType ElementType = PT ? PT->getPointeeType() : OPT->getPointeeType(); 1824db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1825c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = ElementType->getAs<ObjCObjectType>()) { 1826db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 18274a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1828199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext().getTypeSizeInChars(OIT).getQuantity()); 18292a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 18303c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 18312a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 18322a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 18332a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1834db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 18352a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1836db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Explicitly handle GNU void* and function pointer arithmetic extensions. The 1837db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // GNU void* casts amount to no-ops since our void* type is i8*, but this is 1838db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // future proof. 1839b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (ElementType->isVoidType() || ElementType->isFunctionType()) { 18403c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1841b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Casted = Builder.CreateBitCast(Ptr, i8Ty); 18422a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(Casted, Idx, "add.ptr"); 1843b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ptr->getType()); 1844db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1845db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1846664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ptr, Idx, "add.ptr"); 18477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 18487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 18497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) { 18502add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump if (!isa<llvm::PointerType>(Ops.LHS->getType())) { 1851f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasSignedIntegerRepresentation()) { 1852a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner switch (CGF.getContext().getLangOptions().getSignedOverflowBehavior()) { 1853a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Undefined: 1854a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateNSWSub(Ops.LHS, Ops.RHS, "sub"); 1855a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Defined: 1856a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 1857a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner case LangOptions::SOB_Trapping: 1858a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner return EmitOverflowCheckedBinOp(Ops); 1859a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1860a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner } 1861a4d71455f0d418e16cc0c5c5aa55a3bad3494aeeChris Lattner 1862f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Ops.LHS->getType()->isFPOrFPVectorTy()) 186387415d2d45224596a96ef02310701797d56b2c19Chris Lattner return Builder.CreateFSub(Ops.LHS, Ops.RHS, "sub"); 18642eb91e4812d54a1cf634c265a16633a3d3edcf91Chris Lattner 18657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub"); 18662add47387d39ee6c40dcb0e9f3d51c27ad1e113cMike Stump } 18671f1ded9629529085e1673c99fb805e4d9d0b370bChris Lattner 18689a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // Must have binary (not unary) expr here. Unary pointer increment doesn't 18699a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner // use this path. 18709a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const BinaryOperator *BinOp = cast<BinaryOperator>(Ops.E); 18719a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner 18729a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner if (BinOp->getLHS()->getType()->isPointerType() && 18739a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner BinOp->getLHS()->getType()->getAs<PointerType>()->isVariableArrayType()) { 1874daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the addition needs to account for the VLA size for 1875daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-int 1876daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // The amount of the division needs to account for the VLA size for 1877daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // ptr-ptr. 18789a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner CGF.ErrorUnsupported(BinOp, "VLA pointer subtraction"); 1879daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman } 1880daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman 18819a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner const QualType LHSType = BinOp->getLHS()->getType(); 188214108da7f7fc059772711e4ffee1322a27b152a7Steve Naroff const QualType LHSElementType = LHSType->getPointeeType(); 18838c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar if (!isa<llvm::PointerType>(Ops.RHS->getType())) { 18848c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - int 18858c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *Idx = Ops.RHS; 18868c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth(); 18877cabee5b18212bd3106aea8415b044b2b3b43518Sanjiv Gupta if (Width < CGF.LLVMPointerWidth) { 18888c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // Zero or sign extend the pointer value based on whether the index is 18898c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // signed or not. 189077b89b87c3b9220fea1bc80f6d6598d2003cc8a8Chris Lattner const llvm::Type *IdxType = CGF.IntPtrTy; 18919a20723df5904f2da9e4da14bf127366609b5cd8Chris Lattner if (BinOp->getRHS()->getType()->isSignedIntegerType()) 18928c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext"); 18938c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar else 18948c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext"); 18958c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 18968c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Idx = Builder.CreateNeg(Idx, "sub.ptr.neg"); 1897b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar 1898db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // Handle interface types, which are not represented with a concrete type. 1899c12c5bba6ceb6acd4e51e7a0fc03257da9cfd44eJohn McCall if (const ObjCObjectType *OIT = LHSElementType->getAs<ObjCObjectType>()) { 1900db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Value *InterfaceSize = 19014a28d5deeba33722aa009eab488591fb9055cc7eOwen Anderson llvm::ConstantInt::get(Idx->getType(), 1902199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CGF.getContext(). 1903199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck getTypeSizeInChars(OIT).getQuantity()); 19042a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Idx = Builder.CreateMul(Idx, InterfaceSize); 19053c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 19062a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 19072a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "add.ptr"); 19082a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1909db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 19102a866251a80a8d88f6908f7dc68ce06d1023ec1dDaniel Dunbar 1911b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar // Explicitly handle GNU void* and function pointer arithmetic 1912db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // extensions. The GNU void* casts amount to no-ops since our void* type is 1913db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // i8*, but this is future proof. 1914b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 19153c0ef8cc0dc246bd3083e8cdd63005e8873d36d2Benjamin Kramer const llvm::Type *i8Ty = llvm::Type::getInt8PtrTy(VMContext); 1916b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *LHSCasted = Builder.CreateBitCast(Ops.LHS, i8Ty); 1917b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar Value *Res = Builder.CreateGEP(LHSCasted, Idx, "sub.ptr"); 1918b09fae74acfae7af8b3d31b9638a0aa0fdf7c7acDaniel Dunbar return Builder.CreateBitCast(Res, Ops.LHS->getType()); 1919db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump } 1920db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1921664f8934e06cf10de98083b4526aef7bce191a3fDan Gohman return Builder.CreateInBoundsGEP(Ops.LHS, Idx, "sub.ptr"); 1922820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar } else { 19238c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar // pointer - pointer 19248c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *LHS = Ops.LHS; 19258c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *RHS = Ops.RHS; 1926db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1927199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck CharUnits ElementSize; 1928820b03398fdcc8f1f6c60ace55b708e311fa8ce4Daniel Dunbar 1929e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Handle GCC extension for pointer arithmetic on void* and function pointer 1930e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // types. 1931e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner if (LHSElementType->isVoidType() || LHSElementType->isFunctionType()) { 1932199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CharUnits::One(); 19338c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } else { 1934199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck ElementSize = CGF.getContext().getTypeSizeInChars(LHSElementType); 19358c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar } 1936db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 19378c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar const llvm::Type *ResultType = ConvertType(Ops.Ty); 19388c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast"); 19398c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast"); 19408c6f57c38b1451bb28945876b0d147fd2f26e6d3Daniel Dunbar Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub"); 1941db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1942e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner // Optimize out the shift for element size of 1. 1943199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck if (ElementSize.isOne()) 1944e5ed15195b71b8fa440e67d49db0168bb58e4e8aChris Lattner return BytesBetween; 1945df1109434abd465a4db2e6f69ec2688866660367Dan Gohman 1946df1109434abd465a4db2e6f69ec2688866660367Dan Gohman // Otherwise, do a full sdiv. This uses the "exact" form of sdiv, since 1947db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // pointer difference in C is only defined in the case where both operands 1948db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // are pointing to elements of an array. 1949199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck Value *BytesPerElt = 1950199c3d6cd16aebbb9c7f0d42af9d922c9628bf70Ken Dyck llvm::ConstantInt::get(ResultType, ElementSize.getQuantity()); 1951df1109434abd465a4db2e6f69ec2688866660367Dan Gohman return Builder.CreateExactSDiv(BytesBetween, BytesPerElt, "sub.ptr.div"); 19527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 19537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) { 19567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 19577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 19587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 19597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 19607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1961db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1962be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 1963be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1964be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1965be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1966be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1967be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 196815037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 1969be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 1970be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 1971be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 19727f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateShl(Ops.LHS, RHS, "shl"); 19737f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 19757f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) { 19767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // LLVM requires the LHS and RHS to be the same type: promote or truncate the 19777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // RHS to the same size as the LHS. 19787f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Ops.RHS; 19797f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (Ops.LHS->getType() != RHS->getType()) 19807f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom"); 1981db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1982be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump if (CGF.CatchUndefined 1983be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump && isa<llvm::IntegerType>(Ops.LHS->getType())) { 1984be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump unsigned Width = cast<llvm::IntegerType>(Ops.LHS->getType())->getBitWidth(); 1985be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::BasicBlock *Cont = CGF.createBasicBlock("cont"); 1986be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.Builder.CreateCondBr(Builder.CreateICmpULT(RHS, 1987be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump llvm::ConstantInt::get(RHS->getType(), Width)), 198815037caa1542bb810ad54c653aeb80f61df7b00cMike Stump Cont, CGF.getTrapBB()); 1989be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump CGF.EmitBlock(Cont); 1990be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump } 1991be07f60131bc6f8d6696f4644df1ef667a1730d5Mike Stump 1992f60946222721d9ba3c059563935c17b84703187aDouglas Gregor if (Ops.Ty->hasUnsignedIntegerRepresentation()) 19937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateLShr(Ops.LHS, RHS, "shr"); 19947f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Builder.CreateAShr(Ops.LHS, RHS, "shr"); 19957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 19967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 1997aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsevenum IntrinsicType { VCMPEQ, VCMPGT }; 1998aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev// return corresponding comparison intrinsic for given vector type 1999aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsevstatic llvm::Intrinsic::ID GetIntrinsic(IntrinsicType IT, 2000aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev BuiltinType::Kind ElemKind) { 2001aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev switch (ElemKind) { 2002aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev default: assert(0 && "unexpected element type"); 2003aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Char_U: 2004aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UChar: 2005aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 2006aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtub_p; 2007aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2008aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Char_S: 2009aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::SChar: 2010aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequb_p : 2011aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsb_p; 2012aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2013aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UShort: 2014aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 2015aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtuh_p; 2016aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2017aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Short: 2018aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequh_p : 2019aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsh_p; 2020aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2021aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::UInt: 2022aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::ULong: 2023aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 2024aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtuw_p; 2025aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2026aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Int: 2027aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Long: 2028aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpequw_p : 2029aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtsw_p; 2030aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2031aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BuiltinType::Float: 2032aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return (IT == VCMPEQ) ? llvm::Intrinsic::ppc_altivec_vcmpeqfp_p : 2033aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ppc_altivec_vcmpgtfp_p; 2034aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2035aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2036aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return llvm::Intrinsic::not_intrinsic; 2037aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev} 2038aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 20397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc, 20407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner unsigned SICmpOpc, unsigned FCmpOpc) { 20417f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 20424f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *Result; 20437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner QualType LHSTy = E->getLHS()->getType(); 20440bab0cdab751248ca389a5592bcb70eac5d39260John McCall if (const MemberPointerType *MPT = LHSTy->getAs<MemberPointerType>()) { 20452de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_EQ || 20462de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall E->getOpcode() == BO_NE); 2047d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *LHS = CGF.EmitScalarExpr(E->getLHS()); 2048d608cdb7c044365cf4e8764ade1e11e99c176078John McCall Value *RHS = CGF.EmitScalarExpr(E->getRHS()); 20490bab0cdab751248ca389a5592bcb70eac5d39260John McCall Result = CGF.CGM.getCXXABI().EmitMemberPointerComparison( 20502de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall CGF, LHS, RHS, MPT, E->getOpcode() == BO_NE); 2051b81c786de58ce484230dc04f9a7c78bc48990106Eli Friedman } else if (!LHSTy->isAnyComplexType()) { 20527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *LHS = Visit(E->getLHS()); 20537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 2054db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2055aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // If AltiVec, the comparison results in a numeric type, so we use 2056aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // intrinsics comparing vectors and giving 0 or 1 as a result 2057aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (LHSTy->isVectorType() && CGF.getContext().getLangOptions().AltiVec) { 2058aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // constants for mapping CR6 register bits to predicate result 2059aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev enum { CR6_EQ=0, CR6_EQ_REV, CR6_LT, CR6_LT_REV } CR6; 2060aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2061aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Intrinsic::ID ID = llvm::Intrinsic::not_intrinsic; 2062aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2063aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev // in several cases vector arguments order will be reversed 2064aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Value *FirstVecArg = LHS, 2065aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev *SecondVecArg = RHS; 2066aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2067aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev QualType ElTy = LHSTy->getAs<VectorType>()->getElementType(); 2068f4c7371fb1d3cebcfb40abad4537bb82515704eaJohn McCall const BuiltinType *BTy = ElTy->getAs<BuiltinType>(); 2069aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev BuiltinType::Kind ElementKind = BTy->getKind(); 2070aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2071aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev switch(E->getOpcode()) { 2072aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev default: assert(0 && "is not a comparison operation"); 2073aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_EQ: 2074aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2075aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPEQ, ElementKind); 2076aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2077aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_NE: 2078aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2079aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPEQ, ElementKind); 2080aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2081aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_LT: 2082aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2083aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2084aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2085aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2086aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_GT: 2087aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2088aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2089aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2090aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_LE: 2091aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (ElementKind == BuiltinType::Float) { 2092aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2093aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 2094aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2095aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2096aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev else { 2097aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2098aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2099aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2100aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2101aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev case BO_GE: 2102aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev if (ElementKind == BuiltinType::Float) { 2103aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_LT; 2104aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = llvm::Intrinsic::ppc_altivec_vcmpgefp_p; 2105aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2106aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev else { 2107aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev CR6 = CR6_EQ; 2108aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev ID = GetIntrinsic(VCMPGT, ElementKind); 2109aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev std::swap(FirstVecArg, SecondVecArg); 2110aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2111aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev break; 2112aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2113aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2114aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Value *CR6Param = llvm::ConstantInt::get(CGF.Int32Ty, CR6); 2115aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev llvm::Function *F = CGF.CGM.getIntrinsic(ID); 2116aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev Result = Builder.CreateCall3(F, CR6Param, FirstVecArg, SecondVecArg, ""); 2117aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 2118aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev } 2119aa4fe05939ffbfd746b8f0065cc0b5e06ea94fe2Anton Yartsev 2120f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (LHS->getType()->isFPOrFPVectorTy()) { 21217a66d7b6c0d84f8c9c74c687a338cf3cf6b9c808Nate Begeman Result = Builder.CreateFCmp((llvm::CmpInst::Predicate)FCmpOpc, 21227f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 2123f60946222721d9ba3c059563935c17b84703187aDouglas Gregor } else if (LHSTy->hasSignedIntegerRepresentation()) { 2124ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc, 21257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 21267f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 2127ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman // Unsigned integers and pointers. 2128ec2c12646aee07bf6bb1b4092d538d5860fd0661Eli Friedman Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 21297f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS, RHS, "cmp"); 21307f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 21319c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner 21329c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // If this is a vector comparison, sign extend the result to the appropriate 21339c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner // vector integer type and return it (don't convert to bool). 21349c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner if (LHSTy->isVectorType()) 21359c10fcfc3b9d2076efe701b60644a9987a93c503Chris Lattner return Builder.CreateSExt(Result, ConvertType(E->getType()), "sext"); 2136db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21377f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 21387f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex Comparison: can only be an equality comparison. 21397f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS()); 21407f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS()); 2141db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2142183700f494ec9b6701b6efe82bcb25f4c79ba561John McCall QualType CETy = LHSTy->getAs<ComplexType>()->getElementType(); 2143db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21444f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner Value *ResultR, *ResultI; 21457f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner if (CETy->isRealFloatingType()) { 21467f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 21477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 21487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc, 21497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 21507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 21517f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Complex comparisons can only be equality comparisons. As such, signed 21527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // and unsigned opcodes are the same. 21537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 21547f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.first, RHS.first, "cmp.r"); 21557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc, 21567f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHS.second, RHS.second, "cmp.i"); 21577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 2158db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 21592de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall if (E->getOpcode() == BO_EQ) { 21607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateAnd(ResultR, ResultI, "and.ri"); 21617f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } else { 21622de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall assert(E->getOpcode() == BO_NE && 21637f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Complex comparison other than == or != ?"); 21647f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Result = Builder.CreateOr(ResultR, ResultI, "or.ri"); 21657f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 21667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner } 216732f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes 216832f6209ea9a5a88ad3f8d7ad5e5b160b403d12daNuno Lopes return EmitScalarConversion(Result, CGF.getContext().BoolTy, E->getType()); 21697f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 21707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 21717f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) { 21727f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool Ignore = TestAndClearIgnoreResultAssign(); 21737f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 21747f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __block variables need to have the rhs evaluated first, plus this should 21757f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // improve codegen just a little. 21767f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHS = Visit(E->getRHS()); 2177b14e62d5aee7522b98c410ee65bd750c2cfe6f01Mike Stump LValue LHS = EmitCheckedLValue(E->getLHS()); 2178db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2179ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar // Store the value into the LHS. Bit-fields are handled specially 2180371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // because the result is altered by the store, i.e., [C99 6.5.16p1] 2181371d16f45aeec61c1d07687f763d92137e133642Daniel Dunbar // 'An assignment expression has the value of the left operand after 2182daa24a29f881fb2ae53c4022e593eda1adf4b95bEli Friedman // the assignment...'. 2183d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (LHS.isBitField()) 2184d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar CGF.EmitStoreThroughBitfieldLValue(RValue::get(RHS), LHS, E->getType(), 2185d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar &RHS); 2186d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar else 2187ed3849b456d64d124bddc7ac044f3ce590bd9d69Daniel Dunbar CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType()); 2188d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2189d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the result is clearly ignored, return now. 21907f79f9be5916c51c35da4f126b7c12596a101607Mike Stump if (Ignore) 21917f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return 0; 2192d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2193b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 2194b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!CGF.getContext().getLangOptions().CPlusPlus) 2195b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return RHS; 2196b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 2197d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Objective-C property assignment never reloads the value following a store. 2198119a1c6c4029d30cae7b31a2826aa0ff70d01668John McCall if (LHS.isPropertyRef()) 2199d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2200d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2201d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // If the lvalue is non-volatile, return the computed value of the assignment. 2202d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar if (!LHS.isVolatileQualified()) 2203d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar return RHS; 2204d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar 2205d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar // Otherwise, reload the value. 22067f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return EmitLoadOfLValue(LHS, E->getType()); 22077f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 22087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 22097f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) { 22107804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 22117804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 221220eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 && RHS, see if we can elide RHS, if so, just return 0. 221320eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 && X, just emit X without inserting the control flow. 221420eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 221520eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == 1) { // If we have 1 && X, just emit X. 22160946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 22177804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 22187804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "land.ext"); 22190946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2220db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22217804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 0 && RHS: If it is safe, just elide the RHS, and return 0/false. 222220eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 22237804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::Constant::getNullValue(ResTy); 22240946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2225db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22269615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("land.end"); 22279615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("land.rhs"); 222820eb09d562b80420a3328be789547af354bf3e36Chris Lattner 2229f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is false, go to the failure (cont) block. 2230f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), RHSBlock, ContBlock); 2231f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2232f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2233f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be false. Start 2234f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 22350032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 22360032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2237f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 2238f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2239f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 22403b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getFalse(VMContext), *PI); 2241db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 224272119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 22437f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 22447f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 224572119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 2246db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22477f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 22487f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2249f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2250f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2251f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 22527f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 22537f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2254db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22557f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 22567804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "land.ext"); 22577f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 22587f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 22597f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) { 22607804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner const llvm::Type *ResTy = ConvertType(E->getType()); 22617804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner 226220eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 1 || RHS, see if we can elide RHS, if so, just return 1. 226320eb09d562b80420a3328be789547af354bf3e36Chris Lattner // If we have 0 || X, just emit X without inserting the control flow. 226420eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getLHS())) { 226520eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (Cond == -1) { // If we have 0 || X, just emit X. 22660946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 22677804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // ZExt result to int or bool. 22687804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(RHSCond, ResTy, "lor.ext"); 22690946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2270db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22717804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner // 1 || RHS: If it is safe, just elide the RHS, and return 1/true. 227220eb09d562b80420a3328be789547af354bf3e36Chris Lattner if (!CGF.ContainsLabel(E->getRHS())) 22737804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return llvm::ConstantInt::get(ResTy, 1); 22740946ccd1e58c1f1da31ddbca67c5b6301ac8b255Chris Lattner } 2275db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 22769615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("lor.end"); 22779615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("lor.rhs"); 2278db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2279f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Branch on the LHS first. If it is true, go to the success (cont) block. 2280f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBranchOnBoolExpr(E->getLHS(), ContBlock, RHSBlock); 2281f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 2282f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Any edges into the ContBlock are now from an (indeterminate number of) 2283f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // edges from this first condition. All of these values will be true. Start 2284f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // setting up the PHI node in the Cont Block for this. 22850032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson llvm::PHINode *PN = llvm::PHINode::Create(llvm::Type::getInt1Ty(VMContext), 22860032b2781b4deb131f8c9b7968f2030bf2489cddOwen Anderson "", ContBlock); 2287f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PN->reserveOperandSpace(2); // Normal case, two inputs. 2288f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner for (llvm::pred_iterator PI = pred_begin(ContBlock), PE = pred_end(ContBlock); 2289f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner PI != PE; ++PI) 22903b144ba615c32f3cfa5309060ed5e09c89ac2871Owen Anderson PN->addIncoming(llvm::ConstantInt::getTrue(VMContext), *PI); 2291f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner 229272119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 229333da07db112f4877f6ab13e20db08b9bb86a0c2eAnders Carlsson 2294f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit the RHS condition as a bool value. 22957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 22967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS()); 2297db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 229872119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 2299db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23007f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Reaquire the RHS block, as there may be subblocks inserted. 23017f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2302db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2303f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // Emit an unconditional branch from this block to ContBlock. Insert an entry 2304f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner // into the phi node for the edge with the value of RHSCond. 2305f7b5ea9de3d043fa900ab8a8976a4c0eefc233b7Chris Lattner CGF.EmitBlock(ContBlock); 23067f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHSCond, RHSBlock); 2307db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23087f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // ZExt result to int. 23097804bcba90bf5ea8ec6cd0f6cc9a64577f1a9259Chris Lattner return Builder.CreateZExtOrBitCast(PN, ResTy, "lor.ext"); 23107f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23117f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23127f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) { 23132a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E->getLHS()); 2314a448fb2da03ece39978784793eea68760e8205a1Daniel Dunbar CGF.EnsureInsertPoint(); 23157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return Visit(E->getRHS()); 23167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 23177f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23187f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 23197f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Other Operators 23207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 23217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 23229802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// isCheapEnoughToEvaluateUnconditionally - Return true if the specified 23239802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// expression is cheap enough and side-effect-free enough to evaluate 23249802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// unconditionally instead of conditionally. This is used to convert control 23259802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner/// flow into selects in some cases. 2326df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stumpstatic bool isCheapEnoughToEvaluateUnconditionally(const Expr *E, 2327df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CodeGenFunction &CGF) { 23289802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const ParenExpr *PE = dyn_cast<ParenExpr>(E)) 2329df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump return isCheapEnoughToEvaluateUnconditionally(PE->getSubExpr(), CGF); 2330db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23319802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // TODO: Allow anything we can constant fold to an integer or fp constant. 23329802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (isa<IntegerLiteral>(E) || isa<CharacterLiteral>(E) || 23339802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner isa<FloatingLiteral>(E)) 23349802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2335db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23369802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // Non-volatile automatic variables too, to get "cond ? X : Y" where 23379802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // X and Y are local variables. 23389802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const DeclRefExpr *DRE = dyn_cast<DeclRefExpr>(E)) 23399802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner if (const VarDecl *VD = dyn_cast<VarDecl>(DRE->getDecl())) 2340df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (VD->hasLocalStorage() && !(CGF.getContext() 2341df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .getCanonicalType(VD->getType()) 2342df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump .isVolatileQualified())) 23439802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return true; 2344db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23459802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return false; 23469802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner} 23479802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 23489802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner 23497f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter:: 23507f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerVisitConditionalOperator(const ConditionalOperator *E) { 23517f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreResultAssign(); 235231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the condition constant folds and can be elided, try to avoid emitting 235331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the condition and the dead arm. 235431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (int Cond = CGF.ConstantFoldsToSimpleInteger(E->getCond())){ 2355c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner Expr *Live = E->getLHS(), *Dead = E->getRHS(); 235631a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if (Cond == -1) 2357c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner std::swap(Live, Dead); 2358db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 235931a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // If the dead side doesn't have labels we need, and if the Live side isn't 236031a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // the gnu missing ?: extension (which we could handle, but don't bother 236131a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner // to), just emit the Live part. 236231a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner if ((!Dead || !CGF.ContainsLabel(Dead)) && // No labels in dead part 236331a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner Live) // Live part isn't missing. 236431a0984b5cb4af99d2407c0f25bf5af68df681c6Chris Lattner return Visit(Live); 2365c657e92d7b44568fe39ae018a69b18cbcc4ea3b0Chris Lattner } 2366db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 23676155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // OpenCL: If the condition is a vector, we can treat this condition like 23686155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // the select function. 23696155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (CGF.getContext().getLangOptions().OpenCL 23706155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman && E->getCond()->getType()->isVectorType()) { 23716155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *CondV = CGF.EmitScalarExpr(E->getCond()); 23726155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *LHS = Visit(E->getLHS()); 23736155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *RHS = Visit(E->getRHS()); 23746155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 23756155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::Type *condType = ConvertType(E->getCond()->getType()); 23766155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::VectorType *vecTy = cast<llvm::VectorType>(condType); 23776155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 23786155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman unsigned numElem = vecTy->getNumElements(); 23796155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::Type *elemType = vecTy->getElementType(); 23806155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 23816155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman std::vector<llvm::Constant*> Zvals; 23826155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman for (unsigned i = 0; i < numElem; ++i) 23836155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman Zvals.push_back(llvm::ConstantInt::get(elemType,0)); 23846155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 23856155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *zeroVec = llvm::ConstantVector::get(Zvals); 23866155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *TestMSB = Builder.CreateICmpSLT(CondV, zeroVec); 23876155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp = Builder.CreateSExt(TestMSB, 23886155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::VectorType::get(elemType, 23896155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman numElem), 23906155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman "sext"); 23916155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp2 = Builder.CreateNot(tmp); 23926155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 23936155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman // Cast float to int to perform ANDs if necessary. 23946155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *RHSTmp = RHS; 23956155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *LHSTmp = LHS; 23966155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman bool wasCast = false; 23976155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman const llvm::VectorType *rhsVTy = cast<llvm::VectorType>(RHS->getType()); 23986155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (rhsVTy->getElementType()->isFloatTy()) { 23996155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman RHSTmp = Builder.CreateBitCast(RHS, tmp2->getType()); 24006155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman LHSTmp = Builder.CreateBitCast(LHS, tmp->getType()); 24016155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman wasCast = true; 24026155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 24036155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24046155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp3 = Builder.CreateAnd(RHSTmp, tmp2); 24056155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp4 = Builder.CreateAnd(LHSTmp, tmp); 24066155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman llvm::Value *tmp5 = Builder.CreateOr(tmp3, tmp4, "cond"); 24076155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman if (wasCast) 24086155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman tmp5 = Builder.CreateBitCast(tmp5, RHS->getType()); 2409db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24106155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman return tmp5; 24116155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman } 24126155d73ad1668be5335b1a060f6c49c03d4dca05Nate Begeman 24139802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // If this is a really simple expression (like x ? 4 : 5), emit this as a 24149802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner // select instead of as control flow. We can only do this if it is cheap and 2415531a550531c144a58438f187816abbf1879e1c4eChris Lattner // safe to evaluate the LHS and RHS unconditionally. 2416df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump if (E->getLHS() && isCheapEnoughToEvaluateUnconditionally(E->getLHS(), 2417df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump CGF) && 2418df317bf71653eeb235da8337b1e8e790f9653aa4Mike Stump isCheapEnoughToEvaluateUnconditionally(E->getRHS(), CGF)) { 24199802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *CondV = CGF.EvaluateExprAsBool(E->getCond()); 24209802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *LHS = Visit(E->getLHS()); 24219802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner llvm::Value *RHS = Visit(E->getRHS()); 24229802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner return Builder.CreateSelect(CondV, LHS, RHS, "cond"); 24239802a5173ffd403d9ede2d4b6b6107fa2e220544Chris Lattner } 2424db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2425be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 2426be65abc8e41213ecb951f2f507fb2e13a151d30cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 24279615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 2428af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian 2429db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // If we don't have the GNU missing condition extension, emit a branch on bool 2430db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump // the normal way. 243112d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner if (E->getLHS()) { 243212d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, just use EmitBranchOnBoolExpr to get small and simple code for 243312d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the branch on bool. 243412d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 243512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner } else { 243612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // Otherwise, for the ?: extension, evaluate the conditional and then 243712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // convert it to bool the hard way. We do this explicitly because we need 243812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // the unconverted value for the missing middle value of the ?:. 2439af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Expr *save = E->getSAVE(); 2440af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian assert(save && "VisitConditionalOperator - save is null"); 2441af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian // Intentianlly not doing direct assignment to ConditionalSaveExprs[save] !! 2442af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *SaveVal = CGF.EmitScalarExpr(save); 2443af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian CGF.ConditionalSaveExprs[save] = SaveVal; 2444af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *CondVal = Visit(E->getCond()); 244512d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // In some cases, EmitScalarConversion will delete the "CondVal" expression 244612d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // if there are no extra uses (an optimization). Inhibit this by making an 244712d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // extra dead use, because we're going to add a use of CondVal later. We 244812d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // don't use the builder for this, because we don't want it to get optimized 244912d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner // away. This leaves dead code, but the ?: extension isn't common. 245012d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner new llvm::BitCastInst(CondVal, CondVal->getType(), "dummy?:holder", 245112d152f61ccef9a2c0372ba39be7cf416c6e1a9eChris Lattner Builder.GetInsertBlock()); 2452db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2453035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Value *CondBoolVal = 2454035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.EmitScalarConversion(CondVal, E->getCond()->getType(), 2455035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner CGF.getContext().BoolTy); 2456035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock); 2457035cf4294319271ad19ddcc5ba327c8365f3575eChris Lattner } 2458fb6fa30a9b06670deb14f862dddbc49a12552939Anders Carlsson 245972119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 24607f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(LHSBlock); 2461db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24627f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Handle the GNU extension for missing LHS. 2463af9b96828f9126d993c3e155b8453be62013b735Fariborz Jahanian Value *LHS = Visit(E->getTrueExpr()); 2464db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 246572119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 24667f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner LHSBlock = Builder.GetInsertBlock(); 2467d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 2468db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 246972119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.BeginConditionalBranch(); 24707f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(RHSBlock); 2471db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 2472856226c37ff10955c7f3f07ce6fa9522da23a3a5Eli Friedman Value *RHS = Visit(E->getRHS()); 247372119a887c4af39c90f10b6bdc158389071f42eaAnders Carlsson CGF.EndConditionalBranch(); 24747f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner RHSBlock = Builder.GetInsertBlock(); 2475d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 2476db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24777f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner CGF.EmitBlock(ContBlock); 2478db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 247948daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman // If the LHS or RHS is a throw expression, it will be legitimately null. 248048daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!LHS) 248148daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return RHS; 248248daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman if (!RHS) 248348daf59c9f52856ca80074f1f5a30aa29c235726Eli Friedman return LHS; 2484db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 24857f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner // Create a PHI node for the real part. 24867f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond"); 24877f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->reserveOperandSpace(2); 24887f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(LHS, LHSBlock); 24897f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner PN->addIncoming(RHS, RHSBlock); 24907f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner return PN; 24917f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 24927f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 24937f02f721d48772e4eee4fccd8af4f800be1bbc1eChris LattnerValue *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) { 24947976932a1c256d447316ffac58e9821417725e34Eli Friedman return Visit(E->getChosenSubExpr(CGF.getContext())); 24957f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 24967f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 24972202bce80fc72d067cbe67dc1512f7b45351fd31Chris LattnerValue *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) { 24984fd0aa5803357d8c72eeac2cae15e12649ea08feEli Friedman llvm::Value *ArgValue = CGF.EmitVAListRef(VE->getSubExpr()); 2499ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, VE->getType()); 2500ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 2501ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson // If EmitVAArg fails, we fall back to the LLVM instruction. 2502db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump if (!ArgPtr) 2503ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateVAArg(ArgValue, ConvertType(VE->getType())); 2504ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson 25057f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // FIXME Volatility. 2506ddf7cac45d85b73127adbbd91a2b28fc7291c57eAnders Carlsson return Builder.CreateLoad(ArgPtr); 25077c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson} 25087c50aca2fe36f6daa9bf1c8c428f30e72f96470aAnders Carlsson 2509df6b68c9487aed2042c7fc23db10a79f89083a11Mike StumpValue *ScalarExprEmitter::VisitBlockExpr(const BlockExpr *BE) { 25100892099dbc640720400a1d9decd2733a09d733e5Mike Stump return CGF.BuildBlockLiteralTmp(BE); 2511df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump} 2512df6b68c9487aed2042c7fc23db10a79f89083a11Mike Stump 25137f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 25147f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner// Entry Point into this File 25157f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner//===----------------------------------------------------------------------===// 25167f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner 2517db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitScalarExpr - Emit the computation of the specified expression of scalar 2518db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type, ignoring the result. 25197f79f9be5916c51c35da4f126b7c12596a101607Mike StumpValue *CodeGenFunction::EmitScalarExpr(const Expr *E, bool IgnoreResultAssign) { 25207f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner assert(E && !hasAggregateLLVMType(E->getType()) && 25217f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner "Invalid scalar expression to emit"); 2522db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 25237f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return ScalarExprEmitter(*this, IgnoreResultAssign) 25247f79f9be5916c51c35da4f126b7c12596a101607Mike Stump .Visit(const_cast<Expr*>(E)); 25257f02f721d48772e4eee4fccd8af4f800be1bbc1eChris Lattner} 25263707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner 25273707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// EmitScalarConversion - Emit a conversion from the specified type to the 25283707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner/// specified destination type, both of which are LLVM scalar types. 25294f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy, 25304f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 25313707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) && 25323707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner "Invalid scalar expression to emit"); 25333707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy); 25343707b255f8993fb362904c9cff87b0e9bc6ca317Chris Lattner} 25354f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner 2536db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// EmitComplexToScalarConversion - Emit a conversion from the specified complex 2537db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// type to the specified destination type, where the destination type is an 2538db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump/// LLVM scalar type. 25394f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris LattnerValue *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src, 25404f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType SrcTy, 25414f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner QualType DstTy) { 25429b2dc287177394a8f73833e2ad4f7ca8cd6f22bbChris Lattner assert(SrcTy->isAnyComplexType() && !hasAggregateLLVMType(DstTy) && 25434f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner "Invalid complex -> scalar conversion"); 25444f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy, 25454f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner DstTy); 25464f1a7b380809b4ca19ad2daff61bc11cd1e979d8Chris Lattner} 2547cc23acae84c6d5c37b4805edbcd95ee5d821c400Anders Carlsson 25488c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 25498c11a65c18ae607b7073e1e451264492d2297726Chris Lattnerllvm::Value *CodeGenFunction:: 25508c11a65c18ae607b7073e1e451264492d2297726Chris LattnerEmitScalarPrePostIncDec(const UnaryOperator *E, LValue LV, 25518c11a65c18ae607b7073e1e451264492d2297726Chris Lattner bool isInc, bool isPre) { 25528c11a65c18ae607b7073e1e451264492d2297726Chris Lattner return ScalarExprEmitter(*this).EmitScalarPrePostIncDec(E, LV, isInc, isPre); 25538c11a65c18ae607b7073e1e451264492d2297726Chris Lattner} 25548c11a65c18ae607b7073e1e451264492d2297726Chris Lattner 2555820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz JahanianLValue CodeGenFunction::EmitObjCIsaExpr(const ObjCIsaExpr *E) { 2556820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian llvm::Value *V; 2557820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // object->isa or (*object).isa 2558820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // Generate code as for: *(Class*)object 25595ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian // build Class* type 25605ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian const llvm::Type *ClassPtrTy = ConvertType(E->getType()); 25615ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian 2562820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian Expr *BaseExpr = E->getBase(); 25637eb0a9eb0cde8444b97f9c5b713d9be7a6f1e607John McCall if (BaseExpr->isRValue()) { 25645ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian V = CreateTempAlloca(ClassPtrTy, "resval"); 25655ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian llvm::Value *Src = EmitScalarExpr(BaseExpr); 25665ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian Builder.CreateStore(Src, V); 25679f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue( 25689f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar MakeAddrLValue(V, E->getType()), E->getType()); 25699f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar } else { 25709f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar if (E->isArrow()) 25719f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = ScalarExprEmitter(*this).EmitLoadOfLValue(BaseExpr); 25729f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar else 25739f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar V = EmitLValue(BaseExpr).getAddress(); 25745ed676c90c839c89093b605d76c7e581ab69ebb8Fariborz Jahanian } 2575820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 2576820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian // build Class* type 2577820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian ClassPtrTy = ClassPtrTy->getPointerTo(); 2578820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian V = Builder.CreateBitCast(V, ClassPtrTy); 25799f553f5b3bd45304dfda6bdc5cd2baac64b3315bDaniel Dunbar return MakeAddrLValue(V, E->getType()); 2580820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian} 2581820bca41c3899374775d2a1dfc2ef2e22aaf1c7bFariborz Jahanian 25826a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 25832a41637a995affa1563f4d82a8b026e326a2faa0John McCallLValue CodeGenFunction::EmitCompoundAssignmentLValue( 25846a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor const CompoundAssignOperator *E) { 25856a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor ScalarExprEmitter Scalar(*this); 2586d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Value *Result = 0; 25876a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor switch (E->getOpcode()) { 25886a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#define COMPOUND_OP(Op) \ 25892de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_##Op##Assign: \ 25906a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor return Scalar.EmitCompoundAssignLValue(E, &ScalarExprEmitter::Emit##Op, \ 2591d7f7d0895dc43db20c43112a24684f11eed305deDaniel Dunbar Result) 25926a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Mul); 25936a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Div); 25946a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Rem); 25956a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Add); 25966a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Sub); 25976a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shl); 25986a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Shr); 25996a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(And); 26006a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Xor); 26016a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor COMPOUND_OP(Or); 26026a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor#undef COMPOUND_OP 26036a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 26042de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemD: 26052de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_PtrMemI: 26062de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Mul: 26072de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Div: 26082de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Rem: 26092de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Add: 26102de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Sub: 26112de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shl: 26122de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Shr: 26132de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LT: 26142de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GT: 26152de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LE: 26162de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_GE: 26172de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_EQ: 26182de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_NE: 26192de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_And: 26202de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Xor: 26212de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Or: 26222de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LAnd: 26232de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_LOr: 26242de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Assign: 26252de56d1d0c3a504ad1529de2677628bdfbb95cd4John McCall case BO_Comma: 26266a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor assert(false && "Not valid compound assignment operators"); 26276a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor break; 26286a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor } 26296a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor 26306a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor llvm_unreachable("Unhandled compound assignment operator"); 26316a03e345bb3c971750920e34a0d7d1ea7c9eceb7Douglas Gregor} 2632