1566b6ce741c742cc3f8cb85e2376ec4a3490ff5fChris Lattner//===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===// 2b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner// 3b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner// The LLVM Compiler Infrastructure 4b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner// 50bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// This file is distributed under the University of Illinois Open Source 60bc735ffcfb223c0186419547abaa5c84482663eChris Lattner// License. See LICENSE.TXT for details. 7b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner// 8b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner//===----------------------------------------------------------------------===// 9b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner// 10b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner// This contains code to emit Expr nodes with complex types as LLVM code. 11b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner// 12b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner//===----------------------------------------------------------------------===// 13b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 14b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner#include "CodeGenFunction.h" 15b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner#include "CodeGenModule.h" 16de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/ASTContext.h" 17de7fb8413b13651fd85b7125d08b3c9ac2816d9dDaniel Dunbar#include "clang/AST/StmtVisitor.h" 18176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines#include "llvm/ADT/STLExtras.h" 1955fc873017f10f6f566b182b70f6fc22aefa3464Chandler Carruth#include "llvm/ADT/SmallString.h" 203b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/Constants.h" 213b844ba7d5be205a9b4f5f0b0d1b7978977f4b8cChandler Carruth#include "llvm/IR/Function.h" 22176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines#include "llvm/IR/Instructions.h" 23176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines#include "llvm/IR/MDBuilder.h" 24176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines#include "llvm/IR/Metadata.h" 25ab96e565d6a5aa770ad31e7cb8100cd6a9b3d8a2JF Bastien#include <algorithm> 26b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattnerusing namespace clang; 27b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattnerusing namespace CodeGen; 28b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 29b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner//===----------------------------------------------------------------------===// 3005ba49cc452ff05f7f65ac0919afbfd85232017aChris Lattner// Complex Expression Emitter 31b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner//===----------------------------------------------------------------------===// 32b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 3358dee10ed2eee34035f62d1c2d32b3639e9182f8Chris Lattnertypedef CodeGenFunction::ComplexPairTy ComplexPairTy; 34b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 359d232c884ea9872d6555df0fd7359699819bc1f1John McCall/// Return the complex type that we are meant to emit. 369d232c884ea9872d6555df0fd7359699819bc1f1John McCallstatic const ComplexType *getComplexType(QualType type) { 379d232c884ea9872d6555df0fd7359699819bc1f1John McCall type = type.getCanonicalType(); 389d232c884ea9872d6555df0fd7359699819bc1f1John McCall if (const ComplexType *comp = dyn_cast<ComplexType>(type)) { 399d232c884ea9872d6555df0fd7359699819bc1f1John McCall return comp; 409d232c884ea9872d6555df0fd7359699819bc1f1John McCall } else { 419d232c884ea9872d6555df0fd7359699819bc1f1John McCall return cast<ComplexType>(cast<AtomicType>(type)->getValueType()); 429d232c884ea9872d6555df0fd7359699819bc1f1John McCall } 439d232c884ea9872d6555df0fd7359699819bc1f1John McCall} 449d232c884ea9872d6555df0fd7359699819bc1f1John McCall 45b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattnernamespace { 4685b4521e34dcd4a0a4a1f0819e1123128e5a3125Benjamin Kramerclass ComplexExprEmitter 47b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> { 48b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner CodeGenFunction &CGF; 4945d196b8387dcefc4df26cda114fa34c6528e928Daniel Dunbar CGBuilderTy &Builder; 507f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreReal; 517f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool IgnoreImag; 52b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattnerpublic: 53b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false) 54b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) { 55b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner } 56b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 57db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 58b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner //===--------------------------------------------------------------------===// 59b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner // Utilities 60b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner //===--------------------------------------------------------------------===// 61b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 627f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool TestAndClearIgnoreReal() { 637f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool I = IgnoreReal; 647f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreReal = false; 657f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return I; 667f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } 677f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool TestAndClearIgnoreImag() { 687f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool I = IgnoreImag; 697f79f9be5916c51c35da4f126b7c12596a101607Mike Stump IgnoreImag = false; 707f79f9be5916c51c35da4f126b7c12596a101607Mike Stump return I; 717f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } 727f79f9be5916c51c35da4f126b7c12596a101607Mike Stump 73b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner /// EmitLoadOfLValue - Given an expression with complex type that represents a 74b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner /// value l-value, this method emits the address of the l-value, then loads 75b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner /// and returns the result. 7646d7d9fac99cdc60faad5f7ff0433c4ccb5a5c25Chris Lattner ComplexPairTy EmitLoadOfLValue(const Expr *E) { 774ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return EmitLoadOfLValue(CGF.EmitLValue(E), E->getExprLoc()); 780e800c9c20d1a658a91096c756c4a4a9e90264fcJohn McCall } 790e800c9c20d1a658a91096c756c4a4a9e90264fcJohn McCall 804ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky ComplexPairTy EmitLoadOfLValue(LValue LV, SourceLocation Loc); 810e800c9c20d1a658a91096c756c4a4a9e90264fcJohn McCall 8246d7d9fac99cdc60faad5f7ff0433c4ccb5a5c25Chris Lattner /// EmitStoreOfComplex - Store the specified real/imag parts into the 8346d7d9fac99cdc60faad5f7ff0433c4ccb5a5c25Chris Lattner /// specified value pointer. 849d232c884ea9872d6555df0fd7359699819bc1f1John McCall void EmitStoreOfComplex(ComplexPairTy Val, LValue LV, bool isInit); 85db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 8687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar /// Emit a cast from complex value Val to DestType. 87ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType, 8887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar QualType DestType, SourceLocation Loc); 8987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar /// Emit a cast from scalar value Val to DestType. 900934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman ComplexPairTy EmitScalarToComplexCast(llvm::Value *Val, QualType SrcType, 9187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar QualType DestType, SourceLocation Loc); 92db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 93b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner //===--------------------------------------------------------------------===// 94b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner // Visitor Methods 95b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner //===--------------------------------------------------------------------===// 96776c64990e8c9dc81c833ccd1a2ddafe79733eb8Chris Lattner 97aa3b57ee9e36a805371e2a543383225cdd2a5d83Fariborz Jahanian ComplexPairTy Visit(Expr *E) { 980e2c34f92f00628d48968dfea096d36381f494cbStephen Hines ApplyDebugLocation DL(CGF, E); 99cf0b2d83666804b377dbe05370a5c9b9bafaaa5aJohn McCall return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E); 100aa3b57ee9e36a805371e2a543383225cdd2a5d83Fariborz Jahanian } 101651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 102b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner ComplexPairTy VisitStmt(Stmt *S) { 1037a9d49fd2bfac00e905b361ba76d26ab5b6c3b09Ted Kremenek S->dump(CGF.getContext().getSourceManager()); 104b219cfc4d75f0a03630b7c4509ef791b7e97b2c8David Blaikie llvm_unreachable("Stmt can't have complex result type!"); 105b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner } 106776c64990e8c9dc81c833ccd1a2ddafe79733eb8Chris Lattner ComplexPairTy VisitExpr(Expr *S); 107b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());} 108f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 109f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne return Visit(GE->getResultExpr()); 110f111d935722ed488144600cea5ed03a6b5069e8fPeter Collingbourne } 111d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL); 11291a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall ComplexPairTy 11391a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) { 11491a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall return Visit(PE->getReplacement()); 11591a5755ad73c5dc1dfb167e448fdd74e75a6df56John McCall } 116db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 117b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner // l-values. 118f4b88a45902af1802a1cb42ba48b1c474474f228John McCall ComplexPairTy VisitDeclRefExpr(DeclRefExpr *E) { 119f4b88a45902af1802a1cb42ba48b1c474474f228John McCall if (CodeGenFunction::ConstantEmission result = CGF.tryEmitAsConstant(E)) { 120dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall if (result.isReference()) 1214ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return EmitLoadOfLValue(result.getReferenceLValue(CGF, E), 1224ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky E->getExprLoc()); 123dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall 124be6d9130585c33aaea3ee152f365031999d8debeEli Friedman llvm::Constant *pair = result.getValue(); 125be6d9130585c33aaea3ee152f365031999d8debeEli Friedman return ComplexPairTy(pair->getAggregateElement(0U), 126be6d9130585c33aaea3ee152f365031999d8debeEli Friedman pair->getAggregateElement(1U)); 127dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall } 128f4b88a45902af1802a1cb42ba48b1c474474f228John McCall return EmitLoadOfLValue(E); 129dd2ecee313b558a9b621ec003b45e0fbc83508d7John McCall } 130db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 13142f963dec21ed86f33ba34dc01140f77c7174768Daniel Dunbar return EmitLoadOfLValue(E); 13242f963dec21ed86f33ba34dc01140f77c7174768Daniel Dunbar } 13342f963dec21ed86f33ba34dc01140f77c7174768Daniel Dunbar ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) { 13442f963dec21ed86f33ba34dc01140f77c7174768Daniel Dunbar return CGF.EmitObjCMessageExpr(E).getComplexVal(); 13542f963dec21ed86f33ba34dc01140f77c7174768Daniel Dunbar } 1368bcd723ea59a33c6104f54eab68ed8d261728f04Chris Lattner ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); } 137d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); } 138e996ffd240f20a1048179d7727a6ee3227261921John McCall ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) { 13956ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall if (E->isGLValue()) 1404ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E), E->getExprLoc()); 14156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall return CGF.getOpaqueRValueMapping(E).getComplexVal(); 142e996ffd240f20a1048179d7727a6ee3227261921John McCall } 143b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 1444b9c2d235fb9449e249d74f48ecfec601650de93John McCall ComplexPairTy VisitPseudoObjectExpr(PseudoObjectExpr *E) { 1454b9c2d235fb9449e249d74f48ecfec601650de93John McCall return CGF.EmitPseudoObjectRValue(E).getComplexVal(); 1464b9c2d235fb9449e249d74f48ecfec601650de93John McCall } 1474b9c2d235fb9449e249d74f48ecfec601650de93John McCall 148e73e8e212e8aea6557c0629bc0330dc38dc32922Chris Lattner // FIXME: CompoundLiteralExpr 149db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 150176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ComplexPairTy EmitCast(CastKind CK, Expr *Op, QualType DestTy); 151d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) { 152d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner // Unlike for scalars, we don't have to worry about function->ptr demotion 153d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner // here. 15477d439a4d69ffe30a7607c07b3ec5113824fd53eDouglas Gregor return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); 155d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner } 156d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner ComplexPairTy VisitCastExpr(CastExpr *E) { 15787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar if (const auto *ECE = dyn_cast<ExplicitCastExpr>(E)) 15887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar CGF.CGM.EmitExplicitCastExprType(ECE, &CGF); 15977d439a4d69ffe30a7607c07b3ec5113824fd53eDouglas Gregor return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); 160d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner } 161419d25ef8ce1b258aba029bc8aa592f324dab890Chris Lattner ComplexPairTy VisitCallExpr(const CallExpr *E); 1627e20d098a8444dd849127233cfa032797e644ad6Chris Lattner ComplexPairTy VisitStmtExpr(const StmtExpr *E); 1637e20d098a8444dd849127233cfa032797e644ad6Chris Lattner 164b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner // Operators. 1653070f98910c5db862ca276b646e290ca22a98141Chris Lattner ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E, 166dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner bool isInc, bool isPre) { 167dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner LValue LV = CGF.EmitLValue(E->getSubExpr()); 168dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre); 169dd36d328730d8c02915d0884541b45ec6ca0049dChris Lattner } 1703070f98910c5db862ca276b646e290ca22a98141Chris Lattner ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) { 1713070f98910c5db862ca276b646e290ca22a98141Chris Lattner return VisitPrePostIncDec(E, false, false); 1723070f98910c5db862ca276b646e290ca22a98141Chris Lattner } 1733070f98910c5db862ca276b646e290ca22a98141Chris Lattner ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) { 1743070f98910c5db862ca276b646e290ca22a98141Chris Lattner return VisitPrePostIncDec(E, true, false); 1753070f98910c5db862ca276b646e290ca22a98141Chris Lattner } 1763070f98910c5db862ca276b646e290ca22a98141Chris Lattner ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) { 1773070f98910c5db862ca276b646e290ca22a98141Chris Lattner return VisitPrePostIncDec(E, false, true); 1783070f98910c5db862ca276b646e290ca22a98141Chris Lattner } 1793070f98910c5db862ca276b646e290ca22a98141Chris Lattner ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) { 1803070f98910c5db862ca276b646e290ca22a98141Chris Lattner return VisitPrePostIncDec(E, true, true); 1813070f98910c5db862ca276b646e290ca22a98141Chris Lattner } 1823070f98910c5db862ca276b646e290ca22a98141Chris Lattner ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 183fa2b9c9103393680889fe09924a3456657b23d46Chris Lattner ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) { 1847f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreReal(); 1857f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreImag(); 186fa2b9c9103393680889fe09924a3456657b23d46Chris Lattner return Visit(E->getSubExpr()); 187fa2b9c9103393680889fe09924a3456657b23d46Chris Lattner } 188fa2b9c9103393680889fe09924a3456657b23d46Chris Lattner ComplexPairTy VisitUnaryMinus (const UnaryOperator *E); 189e98a11c70483b924f558ead1ae24fd6fd70c7df3Chris Lattner ComplexPairTy VisitUnaryNot (const UnaryOperator *E); 1900518999d3adcc289997bd974dce90cc97f5c1c44Sebastian Redl // LNot,Real,Imag never return complex. 191e98a11c70483b924f558ead1ae24fd6fd70c7df3Chris Lattner ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) { 192e98a11c70483b924f558ead1ae24fd6fd70c7df3Chris Lattner return Visit(E->getSubExpr()); 193e98a11c70483b924f558ead1ae24fd6fd70c7df3Chris Lattner } 19404421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 19504421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner return Visit(DAE->getExpr()); 19604421087832a031c90bd58f128c7c0e741db8dd2Chris Lattner } 197c3bf52ced9652f555aa0767bb822ec4c64546212Richard Smith ComplexPairTy VisitCXXDefaultInitExpr(CXXDefaultInitExpr *DIE) { 198c3bf52ced9652f555aa0767bb822ec4c64546212Richard Smith CodeGenFunction::CXXDefaultInitExprScope Scope(CGF); 199c3bf52ced9652f555aa0767bb822ec4c64546212Richard Smith return Visit(DIE->getExpr()); 200c3bf52ced9652f555aa0767bb822ec4c64546212Richard Smith } 2014765fa05b5652fcc4356371c2f481d0ea9a1b007John McCall ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) { 2021a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall CGF.enterFullExpression(E); 2031a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall CodeGenFunction::RunCleanupsScope Scope(CGF); 2041a343ebbf413e8eae6b2737b2b2d79cbf5765571John McCall return Visit(E->getSubExpr()); 2054b76b4fa1a0225bb4113eb67c5dcdbe74a87ec6bAnders Carlsson } 206ed8abf18329df67b0abcbb3a10458bd8c1d2a595Douglas Gregor ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 2077267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 2089d232c884ea9872d6555df0fd7359699819bc1f1John McCall QualType Elem = E->getType()->castAs<ComplexType>()->getElementType(); 209db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 2107267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis return ComplexPairTy(Null, Null); 2117267f7832e5f0c7f951765e201c5a2650eb1637bArgyrios Kyrtzidis } 2123498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 2133498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 2149d232c884ea9872d6555df0fd7359699819bc1f1John McCall QualType Elem = E->getType()->castAs<ComplexType>()->getElementType(); 215db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump llvm::Constant *Null = 216c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 2173498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor return ComplexPairTy(Null, Null); 2183498bdb9e9cb300de74c7b51c92608e2902b2348Douglas Gregor } 219db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 220ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner struct BinOpInfo { 221ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy LHS; 222ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy RHS; 223ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner QualType Ty; // Computation Type. 224db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump }; 225db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 226ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner BinOpInfo EmitBinOps(const BinaryOperator *E); 227b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 228b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall ComplexPairTy (ComplexExprEmitter::*Func) 229b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall (const BinOpInfo &), 2300934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman RValue &Val); 231ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E, 232ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy (ComplexExprEmitter::*Func) 233ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner (const BinOpInfo &)); 234ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner 235ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy EmitBinAdd(const BinOpInfo &Op); 236ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy EmitBinSub(const BinOpInfo &Op); 237ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy EmitBinMul(const BinOpInfo &Op); 238ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy EmitBinDiv(const BinOpInfo &Op); 239db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 240176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ComplexPairTy EmitComplexBinOpLibCall(StringRef LibCallName, 241176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const BinOpInfo &Op); 242176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 243ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy VisitBinAdd(const BinaryOperator *E) { 244ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner return EmitBinAdd(EmitBinOps(E)); 245ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner } 246ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy VisitBinSub(const BinaryOperator *E) { 247ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner return EmitBinSub(EmitBinOps(E)); 248ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner } 249b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall ComplexPairTy VisitBinMul(const BinaryOperator *E) { 250b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return EmitBinMul(EmitBinOps(E)); 251b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall } 252ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy VisitBinDiv(const BinaryOperator *E) { 253ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner return EmitBinDiv(EmitBinOps(E)); 254ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner } 255db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 256ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner // Compound assignments. 257ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) { 258ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd); 259ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner } 260ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) { 261ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub); 262ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner } 263ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) { 264ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul); 265ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner } 266ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) { 267ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv); 268ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner } 269db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 270612c40c21474048defc397c395760d06fed948b6Chris Lattner // GCC rejects rem/and/or/xor for integer complex. 2714034edbf86c4855c0b104111fa6b6a0d9a1f9adaChris Lattner // Logical and/or always return int, never complex. 27258dee10ed2eee34035f62d1c2d32b3639e9182f8Chris Lattner 27358dee10ed2eee34035f62d1c2d32b3639e9182f8Chris Lattner // No comparisons produce a complex result. 274b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 275b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall LValue EmitBinAssignLValue(const BinaryOperator *E, 276b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall ComplexPairTy &Val); 277b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner ComplexPairTy VisitBinAssign (const BinaryOperator *E); 278756a4d88457aebb6c154a4cbb5d595fdb2e0899dChris Lattner ComplexPairTy VisitBinComma (const BinaryOperator *E); 279756a4d88457aebb6c154a4cbb5d595fdb2e0899dChris Lattner 280db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 28156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall ComplexPairTy 28256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO); 283d0b1203b1c982be34a56199c59c53ae15a953667Chris Lattner ComplexPairTy VisitChooseExpr(ChooseExpr *CE); 284c4777f1928913423234d8d534898f22e9792ae52Eli Friedman 285c4777f1928913423234d8d534898f22e9792ae52Eli Friedman ComplexPairTy VisitInitListExpr(InitListExpr *E); 2864e484b8134c7eaeced03be7e4e0f7349def9b355Daniel Dunbar 287fce4715bc343bf788c3767e16f1492b96ef73b8eEli Friedman ComplexPairTy VisitCompoundLiteralExpr(CompoundLiteralExpr *E) { 288fce4715bc343bf788c3767e16f1492b96ef73b8eEli Friedman return EmitLoadOfLValue(E); 289fce4715bc343bf788c3767e16f1492b96ef73b8eEli Friedman } 290fce4715bc343bf788c3767e16f1492b96ef73b8eEli Friedman 2914e484b8134c7eaeced03be7e4e0f7349def9b355Daniel Dunbar ComplexPairTy VisitVAArgExpr(VAArgExpr *E); 292276b061970939293f1abaf694bd3ef05b2cbda79Eli Friedman 293276b061970939293f1abaf694bd3ef05b2cbda79Eli Friedman ComplexPairTy VisitAtomicExpr(AtomicExpr *E) { 294276b061970939293f1abaf694bd3ef05b2cbda79Eli Friedman return CGF.EmitAtomicExpr(E).getComplexVal(); 295276b061970939293f1abaf694bd3ef05b2cbda79Eli Friedman } 296b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner}; 297b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner} // end anonymous namespace. 298b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 299b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner//===----------------------------------------------------------------------===// 300b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner// Utilities 301b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner//===----------------------------------------------------------------------===// 302b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 30387d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga NainarAddress CodeGenFunction::emitAddrOfRealComponent(Address addr, 30487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar QualType complexType) { 30587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar CharUnits offset = CharUnits::Zero(); 30687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar return Builder.CreateStructGEP(addr, 0, offset, addr.getName() + ".realp"); 30787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar} 30887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar 30987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga NainarAddress CodeGenFunction::emitAddrOfImagComponent(Address addr, 31087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar QualType complexType) { 31187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar QualType eltType = complexType->castAs<ComplexType>()->getElementType(); 31287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar CharUnits offset = getContext().getTypeSizeInChars(eltType); 31387d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar return Builder.CreateStructGEP(addr, 1, offset, addr.getName() + ".imagp"); 31487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar} 31587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar 3169d232c884ea9872d6555df0fd7359699819bc1f1John McCall/// EmitLoadOfLValue - Given an RValue reference for a complex, emit code to 31746d7d9fac99cdc60faad5f7ff0433c4ccb5a5c25Chris Lattner/// load the real and imaginary pieces, returning them as Real/Imag. 3184ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick LewyckyComplexPairTy ComplexExprEmitter::EmitLoadOfLValue(LValue lvalue, 3194ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky SourceLocation loc) { 3209d232c884ea9872d6555df0fd7359699819bc1f1John McCall assert(lvalue.isSimple() && "non-simple complex l-value?"); 3219eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall if (lvalue.getType()->isAtomicType()) 3224ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return CGF.EmitAtomicLoad(lvalue, loc).getComplexVal(); 3239eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall 32487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Address SrcPtr = lvalue.getAddress(); 3259d232c884ea9872d6555df0fd7359699819bc1f1John McCall bool isVolatile = lvalue.isVolatileQualified(); 3269d232c884ea9872d6555df0fd7359699819bc1f1John McCall 32787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar llvm::Value *Real = nullptr, *Imag = nullptr; 3286b5d0bf42fa4212f21ebb620b15e1024cb6a2a58Chris Lattner 329ff624c195e3a3f8dc697ead40bae78e84ca72c12John McCall if (!IgnoreReal || isVolatile) { 33087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Address RealP = CGF.emitAddrOfRealComponent(SrcPtr, lvalue.getType()); 33187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr.getName() + ".real"); 3327f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } 333db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 334ff624c195e3a3f8dc697ead40bae78e84ca72c12John McCall if (!IgnoreImag || isVolatile) { 33587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Address ImagP = CGF.emitAddrOfImagComponent(SrcPtr, lvalue.getType()); 33687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr.getName() + ".imag"); 3377f79f9be5916c51c35da4f126b7c12596a101607Mike Stump } 33887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar 339b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner return ComplexPairTy(Real, Imag); 340b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner} 341b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 34246d7d9fac99cdc60faad5f7ff0433c4ccb5a5c25Chris Lattner/// EmitStoreOfComplex - Store the specified real/imag parts into the 34346d7d9fac99cdc60faad5f7ff0433c4ccb5a5c25Chris Lattner/// specified value pointer. 3440e2c34f92f00628d48968dfea096d36381f494cbStephen Hinesvoid ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, LValue lvalue, 3459d232c884ea9872d6555df0fd7359699819bc1f1John McCall bool isInit) { 3460e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (lvalue.getType()->isAtomicType() || 3470e2c34f92f00628d48968dfea096d36381f494cbStephen Hines (!isInit && CGF.LValueIsSuitableForInlineAtomic(lvalue))) 3489eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall return CGF.EmitAtomicStore(RValue::getComplex(Val), lvalue, isInit); 3499eda3abe7e183b05834947391c0cdc291f4ee0d8John McCall 35087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Address Ptr = lvalue.getAddress(); 35187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Address RealPtr = CGF.emitAddrOfRealComponent(Ptr, lvalue.getType()); 35287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Address ImagPtr = CGF.emitAddrOfImagComponent(Ptr, lvalue.getType()); 35387d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar 35487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Builder.CreateStore(Val.first, RealPtr, lvalue.isVolatileQualified()); 35587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Builder.CreateStore(Val.second, ImagPtr, lvalue.isVolatileQualified()); 35646d7d9fac99cdc60faad5f7ff0433c4ccb5a5c25Chris Lattner} 35746d7d9fac99cdc60faad5f7ff0433c4ccb5a5c25Chris Lattner 35846d7d9fac99cdc60faad5f7ff0433c4ccb5a5c25Chris Lattner 35946d7d9fac99cdc60faad5f7ff0433c4ccb5a5c25Chris Lattner 360b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner//===----------------------------------------------------------------------===// 361b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner// Visitor Methods 362b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner//===----------------------------------------------------------------------===// 363b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 364776c64990e8c9dc81c833ccd1a2ddafe79733eb8Chris LattnerComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) { 365776b790fe404360b691f2dd477877a1112db7ad2Fariborz Jahanian CGF.ErrorUnsupported(E, "complex expression"); 366776b790fe404360b691f2dd477877a1112db7ad2Fariborz Jahanian llvm::Type *EltTy = 3679d232c884ea9872d6555df0fd7359699819bc1f1John McCall CGF.ConvertType(getComplexType(E->getType())->getElementType()); 368776b790fe404360b691f2dd477877a1112db7ad2Fariborz Jahanian llvm::Value *U = llvm::UndefValue::get(EltTy); 369776b790fe404360b691f2dd477877a1112db7ad2Fariborz Jahanian return ComplexPairTy(U, U); 370b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner} 371b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 372d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris LattnerComplexPairTy ComplexExprEmitter:: 373d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris LattnerVisitImaginaryLiteral(const ImaginaryLiteral *IL) { 374db68f1bc5a49d4c847543db8245f16466a8889a6Chris Lattner llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); 3758d3d6c93551cc62c6d550f090991bfba1d32d0a4John McCall return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); 376db68f1bc5a49d4c847543db8245f16466a8889a6Chris Lattner} 377db68f1bc5a49d4c847543db8245f16466a8889a6Chris Lattner 378db68f1bc5a49d4c847543db8245f16466a8889a6Chris Lattner 379419d25ef8ce1b258aba029bc8aa592f324dab890Chris LattnerComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { 3800e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (E->getCallReturnType(CGF.getContext())->isReferenceType()) 381e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson return EmitLoadOfLValue(E); 382e9f2f45fe9bf79bd4aea47fa1ad9204b68510fd9Anders Carlsson 3839b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner return CGF.EmitCallExpr(E).getComplexVal(); 38467295d05c50ab0b5d1b0f9ef82a906701c348715Nate Begeman} 38567295d05c50ab0b5d1b0f9ef82a906701c348715Nate Begeman 3867e20d098a8444dd849127233cfa032797e644ad6Chris LattnerComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) { 387150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall CodeGenFunction::StmtExprEvaluation eval(CGF); 38887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Address RetAlloca = CGF.EmitCompoundStmt(*E->getSubStmt(), true); 38987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar assert(RetAlloca.isValid() && "Expected complex return value"); 3904ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return EmitLoadOfLValue(CGF.MakeAddrLValue(RetAlloca, E->getType()), 3914ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky E->getExprLoc()); 3927e20d098a8444dd849127233cfa032797e644ad6Chris Lattner} 3937e20d098a8444dd849127233cfa032797e644ad6Chris Lattner 39487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar/// Emit a cast from complex value Val to DestType. 395ab340c22fee7f536d83242411c40e63aa3718987Chris LattnerComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val, 396ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner QualType SrcType, 39787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar QualType DestType, 39887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar SourceLocation Loc) { 399ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner // Get the src/dest element type. 4009d232c884ea9872d6555df0fd7359699819bc1f1John McCall SrcType = SrcType->castAs<ComplexType>()->getElementType(); 4019d232c884ea9872d6555df0fd7359699819bc1f1John McCall DestType = DestType->castAs<ComplexType>()->getElementType(); 402ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner 40356f0d16c1159d8bc585f583cfc440298e6dbd330Daniel Dunbar // C99 6.3.1.6: When a value of complex type is converted to another 404e12d8e321016c2cc9dfad07a78a74fe2f8d7e884Daniel Dunbar // complex type, both the real and imaginary parts follow the conversion 405ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner // rules for the corresponding real types. 40687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType, Loc); 40787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType, Loc); 408ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner return Val; 409ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner} 410d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner 4110934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli FriedmanComplexPairTy ComplexExprEmitter::EmitScalarToComplexCast(llvm::Value *Val, 4120934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman QualType SrcType, 41387d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar QualType DestType, 41487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar SourceLocation Loc) { 4150934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman // Convert the input element to the element type of the complex. 4160934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman DestType = DestType->castAs<ComplexType>()->getElementType(); 41787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Val = CGF.EmitScalarConversion(Val, SrcType, DestType, Loc); 4180934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman 4190934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman // Return (realval, 0). 4200934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman return ComplexPairTy(Val, llvm::Constant::getNullValue(Val->getType())); 4210934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman} 4220934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman 423176edba5311f6eff0cad2631449885ddf4fbc9eaStephen HinesComplexPairTy ComplexExprEmitter::EmitCast(CastKind CK, Expr *Op, 42477d439a4d69ffe30a7607c07b3ec5113824fd53eDouglas Gregor QualType DestTy) { 425f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall switch (CK) { 4266594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!"); 427f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall 4287a7ee3033e44b45630981355460ef89efa0bdcc4David Chisnall // Atomic to non-atomic casts may be more than a no-op for some platforms and 4297a7ee3033e44b45630981355460ef89efa0bdcc4David Chisnall // for some types. 4307a7ee3033e44b45630981355460ef89efa0bdcc4David Chisnall case CK_AtomicToNonAtomic: 4317a7ee3033e44b45630981355460ef89efa0bdcc4David Chisnall case CK_NonAtomicToAtomic: 432f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall case CK_NoOp: 433f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall case CK_LValueToRValue: 4346594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_UserDefinedConversion: 435f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall return Visit(Op); 436f6a1648197562e0b133440d612d9af297d0a86ccJohn McCall 4376594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_LValueBitCast: { 4389d232c884ea9872d6555df0fd7359699819bc1f1John McCall LValue origLV = CGF.EmitLValue(Op); 43987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Address V = origLV.getAddress(); 44087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar V = Builder.CreateElementBitCast(V, CGF.ConvertType(DestTy)); 44187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar return EmitLoadOfLValue(CGF.MakeAddrLValue(V, DestTy), Op->getExprLoc()); 44277d439a4d69ffe30a7607c07b3ec5113824fd53eDouglas Gregor } 443d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner 4446594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_BitCast: 4456594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_BaseToDerived: 4466594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_DerivedToBase: 4476594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_UncheckedDerivedToBase: 4486594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_Dynamic: 4496594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_ToUnion: 4506594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_ArrayToPointerDecay: 4516594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_FunctionToPointerDecay: 4526594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_NullToPointer: 4536594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_NullToMemberPointer: 4546594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_BaseToDerivedMemberPointer: 4556594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_DerivedToBaseMemberPointer: 4566594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_MemberPointerToBoolean: 4574d4e5c1ae83f4510caa486b3ad19de13048f9f04John McCall case CK_ReinterpretMemberPointer: 4586594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_ConstructorConversion: 4596594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_IntegralToPointer: 4606594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_PointerToIntegral: 4616594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_PointerToBoolean: 4626594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_ToVoid: 4636594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_VectorSplat: 4646594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_IntegralCast: 4654967a710c84587c654b56c828382219c3937dacbPirama Arumuga Nainar case CK_BooleanToSignedIntegral: 4666594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_IntegralToBoolean: 4676594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_IntegralToFloating: 4686594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_FloatingToIntegral: 4696594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_FloatingToBoolean: 4706594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_FloatingCast: 4711d9b3b25f7ac0d0195bba6b507a684fe5e7943eeJohn McCall case CK_CPointerToObjCPointerCast: 4721d9b3b25f7ac0d0195bba6b507a684fe5e7943eeJohn McCall case CK_BlockPointerToObjCPointerCast: 4736594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_AnyPointerToBlockPointerCast: 4746594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_ObjCObjectLValueCast: 4756594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_FloatingComplexToReal: 4766594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_FloatingComplexToBoolean: 4776594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_IntegralComplexToReal: 4786594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_IntegralComplexToBoolean: 47933e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCProduceObject: 48033e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCConsumeObject: 48133e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCReclaimReturnedObject: 48233e56f3273457bfa22c7c50bc46cf5a18216863dJohn McCall case CK_ARCExtendBlockObject: 483ac1303eca6cbe3e623fb5ec6fe7ec184ef4b0dfaDouglas Gregor case CK_CopyAndAutoreleaseBlockObject: 484a6c66cedc022c9e5d45a937d6b8cff491a6bf81bEli Friedman case CK_BuiltinFnToFnPtr: 485e6b9d802fb7b16d93474c4f1c179ab36202e8a8bGuy Benyei case CK_ZeroToOCLEvent: 486651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines case CK_AddressSpaceConversion: 4876594942e98e25640f226aba622eb76bcaf0a521cEli Friedman llvm_unreachable("invalid cast kind for complex value"); 4886594942e98e25640f226aba622eb76bcaf0a521cEli Friedman 4896594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_FloatingRealToComplex: 4900934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman case CK_IntegralRealToComplex: 49187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar return EmitScalarToComplexCast(CGF.EmitScalarExpr(Op), Op->getType(), 49287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar DestTy, Op->getExprLoc()); 4936594942e98e25640f226aba622eb76bcaf0a521cEli Friedman 4946594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_FloatingComplexCast: 4956594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_FloatingComplexToIntegralComplex: 4966594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_IntegralComplexCast: 4976594942e98e25640f226aba622eb76bcaf0a521cEli Friedman case CK_IntegralComplexToFloatingComplex: 49887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy, 49987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Op->getExprLoc()); 5006594942e98e25640f226aba622eb76bcaf0a521cEli Friedman } 501db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 5026594942e98e25640f226aba622eb76bcaf0a521cEli Friedman llvm_unreachable("unknown cast resulting in complex value"); 503d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner} 504d272ff0e0ab59977d02be34687e91bc76c60cfb3Chris Lattner 505fa2b9c9103393680889fe09924a3456657b23d46Chris LattnerComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 5067f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreReal(); 5077f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreImag(); 508fa2b9c9103393680889fe09924a3456657b23d46Chris Lattner ComplexPairTy Op = Visit(E->getSubExpr()); 509db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 51087415d2d45224596a96ef02310701797d56b2c19Chris Lattner llvm::Value *ResR, *ResI; 511f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Op.first->getType()->isFloatingPointTy()) { 51287415d2d45224596a96ef02310701797d56b2c19Chris Lattner ResR = Builder.CreateFNeg(Op.first, "neg.r"); 51387415d2d45224596a96ef02310701797d56b2c19Chris Lattner ResI = Builder.CreateFNeg(Op.second, "neg.i"); 51487415d2d45224596a96ef02310701797d56b2c19Chris Lattner } else { 51587415d2d45224596a96ef02310701797d56b2c19Chris Lattner ResR = Builder.CreateNeg(Op.first, "neg.r"); 51687415d2d45224596a96ef02310701797d56b2c19Chris Lattner ResI = Builder.CreateNeg(Op.second, "neg.i"); 51787415d2d45224596a96ef02310701797d56b2c19Chris Lattner } 518fa2b9c9103393680889fe09924a3456657b23d46Chris Lattner return ComplexPairTy(ResR, ResI); 519fa2b9c9103393680889fe09924a3456657b23d46Chris Lattner} 520fa2b9c9103393680889fe09924a3456657b23d46Chris Lattner 521e98a11c70483b924f558ead1ae24fd6fd70c7df3Chris LattnerComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 5227f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreReal(); 5237f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreImag(); 524e98a11c70483b924f558ead1ae24fd6fd70c7df3Chris Lattner // ~(a+ib) = a + i*-b 525e98a11c70483b924f558ead1ae24fd6fd70c7df3Chris Lattner ComplexPairTy Op = Visit(E->getSubExpr()); 52687415d2d45224596a96ef02310701797d56b2c19Chris Lattner llvm::Value *ResI; 527f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Op.second->getType()->isFloatingPointTy()) 52887415d2d45224596a96ef02310701797d56b2c19Chris Lattner ResI = Builder.CreateFNeg(Op.second, "conj.i"); 52987415d2d45224596a96ef02310701797d56b2c19Chris Lattner else 53087415d2d45224596a96ef02310701797d56b2c19Chris Lattner ResI = Builder.CreateNeg(Op.second, "conj.i"); 531db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 532e98a11c70483b924f558ead1ae24fd6fd70c7df3Chris Lattner return ComplexPairTy(Op.first, ResI); 533e98a11c70483b924f558ead1ae24fd6fd70c7df3Chris Lattner} 534fa2b9c9103393680889fe09924a3456657b23d46Chris Lattner 535ab340c22fee7f536d83242411c40e63aa3718987Chris LattnerComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 53687415d2d45224596a96ef02310701797d56b2c19Chris Lattner llvm::Value *ResR, *ResI; 537db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 538f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Op.LHS.first->getType()->isFloatingPointTy()) { 53987415d2d45224596a96ef02310701797d56b2c19Chris Lattner ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r"); 540176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Op.LHS.second && Op.RHS.second) 541176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i"); 542176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines else 543176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResI = Op.LHS.second ? Op.LHS.second : Op.RHS.second; 544176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines assert(ResI && "Only one operand may be real!"); 54587415d2d45224596a96ef02310701797d56b2c19Chris Lattner } else { 54687415d2d45224596a96ef02310701797d56b2c19Chris Lattner ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 547176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines assert(Op.LHS.second && Op.RHS.second && 548176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines "Both operands of integer complex operators must be complex!"); 54987415d2d45224596a96ef02310701797d56b2c19Chris Lattner ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 55087415d2d45224596a96ef02310701797d56b2c19Chris Lattner } 551b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner return ComplexPairTy(ResR, ResI); 552b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner} 553b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 554ab340c22fee7f536d83242411c40e63aa3718987Chris LattnerComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 55587415d2d45224596a96ef02310701797d56b2c19Chris Lattner llvm::Value *ResR, *ResI; 556f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Op.LHS.first->getType()->isFloatingPointTy()) { 557176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r"); 558176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Op.LHS.second && Op.RHS.second) 559176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i"); 560176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines else 561176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResI = Op.LHS.second ? Op.LHS.second 562176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines : Builder.CreateFNeg(Op.RHS.second, "sub.i"); 563176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines assert(ResI && "Only one operand may be real!"); 56487415d2d45224596a96ef02310701797d56b2c19Chris Lattner } else { 565176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 566176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines assert(Op.LHS.second && Op.RHS.second && 567176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines "Both operands of integer complex operators must be complex!"); 56887415d2d45224596a96ef02310701797d56b2c19Chris Lattner ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 56987415d2d45224596a96ef02310701797d56b2c19Chris Lattner } 5706bc1adec849c8ab1934464c2595baa896e43060fChris Lattner return ComplexPairTy(ResR, ResI); 5716bc1adec849c8ab1934464c2595baa896e43060fChris Lattner} 5726bc1adec849c8ab1934464c2595baa896e43060fChris Lattner 573176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// \brief Emit a libcall for a binary operation on complex types. 574176edba5311f6eff0cad2631449885ddf4fbc9eaStephen HinesComplexPairTy ComplexExprEmitter::EmitComplexBinOpLibCall(StringRef LibCallName, 575176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines const BinOpInfo &Op) { 576176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CallArgList Args; 577176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Args.add(RValue::get(Op.LHS.first), 578176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Op.Ty->castAs<ComplexType>()->getElementType()); 579176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Args.add(RValue::get(Op.LHS.second), 580176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Op.Ty->castAs<ComplexType>()->getElementType()); 581176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Args.add(RValue::get(Op.RHS.first), 582176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Op.Ty->castAs<ComplexType>()->getElementType()); 583176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Args.add(RValue::get(Op.RHS.second), 584176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Op.Ty->castAs<ComplexType>()->getElementType()); 585176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 586176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // We *must* use the full CG function call building logic here because the 5870e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // complex type has special ABI handling. We also should not forget about 5880e2c34f92f00628d48968dfea096d36381f494cbStephen Hines // special calling convention which may be used for compiler builtins. 58987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar 59087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // We create a function qualified type to state that this call does not have 59187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar // any exceptions. 59287d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar FunctionProtoType::ExtProtoInfo EPI; 59387d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar EPI = EPI.withExceptionSpec( 59487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar FunctionProtoType::ExceptionSpecInfo(EST_BasicNoexcept)); 59587d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar SmallVector<QualType, 4> ArgsQTys( 59687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar 4, Op.Ty->castAs<ComplexType>()->getElementType()); 59787d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar QualType FQTy = CGF.getContext().getFunctionType(Op.Ty, ArgsQTys, EPI); 59887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar const CGFunctionInfo &FuncInfo = CGF.CGM.getTypes().arrangeFreeFunctionCall( 59987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Args, cast<FunctionType>(FQTy.getTypePtr()), false); 60087d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar 601176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::FunctionType *FTy = CGF.CGM.getTypes().GetFunctionType(FuncInfo); 6020e2c34f92f00628d48968dfea096d36381f494cbStephen Hines llvm::Constant *Func = CGF.CGM.CreateBuiltinFunction(FTy, LibCallName); 6030e2c34f92f00628d48968dfea096d36381f494cbStephen Hines llvm::Instruction *Call; 6040e2c34f92f00628d48968dfea096d36381f494cbStephen Hines 6050e2c34f92f00628d48968dfea096d36381f494cbStephen Hines RValue Res = CGF.EmitCall(FuncInfo, Func, ReturnValueSlot(), Args, 60687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar FQTy->getAs<FunctionProtoType>(), &Call); 6070e2c34f92f00628d48968dfea096d36381f494cbStephen Hines cast<llvm::CallInst>(Call)->setCallingConv(CGF.CGM.getBuiltinCC()); 6080e2c34f92f00628d48968dfea096d36381f494cbStephen Hines return Res.getComplexVal(); 609176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines} 610176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 611176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// \brief Lookup the libcall name for a given floating point type complex 612176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines/// multiply. 613176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hinesstatic StringRef getComplexMultiplyLibCallName(llvm::Type *Ty) { 614176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines switch (Ty->getTypeID()) { 615176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines default: 616176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm_unreachable("Unsupported floating point type!"); 617176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::HalfTyID: 618176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return "__mulhc3"; 619176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::FloatTyID: 620176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return "__mulsc3"; 621176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::DoubleTyID: 622176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return "__muldc3"; 623176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::PPC_FP128TyID: 624176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return "__multc3"; 625176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::X86_FP80TyID: 626176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return "__mulxc3"; 627176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::FP128TyID: 628176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return "__multc3"; 629176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 630176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines} 6316bc1adec849c8ab1934464c2595baa896e43060fChris Lattner 632176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines// See C11 Annex G.5.1 for the semantics of multiplicative operators on complex 633176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines// typed values. 634ab340c22fee7f536d83242411c40e63aa3718987Chris LattnerComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 63587415d2d45224596a96ef02310701797d56b2c19Chris Lattner using llvm::Value; 63687415d2d45224596a96ef02310701797d56b2c19Chris Lattner Value *ResR, *ResI; 637176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::MDBuilder MDHelper(CGF.getLLVMContext()); 638db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 639f177d9d6c27fbbcee8c00fd90b8306985c03c54aDuncan Sands if (Op.LHS.first->getType()->isFloatingPointTy()) { 640176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // The general formulation is: 641176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // (a + ib) * (c + id) = (a * c - b * d) + i(a * d + b * c) 642176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // 643176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // But we can fold away components which would be zero due to a real 644176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // operand according to C11 Annex G.5.1p2. 645176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // FIXME: C11 also provides for imaginary types which would allow folding 646176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // still more of this within the type system. 647176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 648176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (Op.LHS.second && Op.RHS.second) { 649176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // If both operands are complex, emit the core math directly, and then 650176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // test for NaNs. If we find NaNs in the result, we delegate to a libcall 651176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // to carefully re-compute the correct infinity representation if 652176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // possible. The expectation is that the presence of NaNs here is 653176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // *extremely* rare, and so the cost of the libcall is almost irrelevant. 654176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // This is good, because the libcall re-computes the core multiplication 655176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // exactly the same as we do here and re-tests for NaNs in order to be 656176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // a generic complex*complex libcall. 657176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 658176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // First compute the four products. 659176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Value *AC = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul_ac"); 660176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Value *BD = Builder.CreateFMul(Op.LHS.second, Op.RHS.second, "mul_bd"); 661176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Value *AD = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul_ad"); 662176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Value *BC = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul_bc"); 663176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 664176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // The real part is the difference of the first two, the imaginary part is 665176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // the sum of the second. 666176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResR = Builder.CreateFSub(AC, BD, "mul_r"); 667176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResI = Builder.CreateFAdd(AD, BC, "mul_i"); 668176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 669176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Emit the test for the real part becoming NaN and create a branch to 670176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // handle it. We test for NaN by comparing the number to itself. 671176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Value *IsRNaN = Builder.CreateFCmpUNO(ResR, ResR, "isnan_cmp"); 672176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::BasicBlock *ContBB = CGF.createBasicBlock("complex_mul_cont"); 673176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::BasicBlock *INaNBB = CGF.createBasicBlock("complex_mul_imag_nan"); 674176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::Instruction *Branch = Builder.CreateCondBr(IsRNaN, INaNBB, ContBB); 675176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::BasicBlock *OrigBB = Branch->getParent(); 676176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 677176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Give hint that we very much don't expect to see NaNs. 678176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Value chosen to match UR_NONTAKEN_WEIGHT, see BranchProbabilityInfo.cpp 679176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::MDNode *BrWeight = MDHelper.createBranchWeights(1, (1U << 20) - 1); 680176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight); 681176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 682176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Now test the imaginary part and create its branch. 683176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CGF.EmitBlock(INaNBB); 684176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Value *IsINaN = Builder.CreateFCmpUNO(ResI, ResI, "isnan_cmp"); 685176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::BasicBlock *LibCallBB = CGF.createBasicBlock("complex_mul_libcall"); 686176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Branch = Builder.CreateCondBr(IsINaN, LibCallBB, ContBB); 687176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Branch->setMetadata(llvm::LLVMContext::MD_prof, BrWeight); 688176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 689176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Now emit the libcall on this slowest of the slow paths. 690176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CGF.EmitBlock(LibCallBB); 691176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Value *LibCallR, *LibCallI; 692176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines std::tie(LibCallR, LibCallI) = EmitComplexBinOpLibCall( 693176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines getComplexMultiplyLibCallName(Op.LHS.first->getType()), Op); 694176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Builder.CreateBr(ContBB); 695176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 696176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // Finally continue execution by phi-ing together the different 697176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // computation paths. 698176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CGF.EmitBlock(ContBB); 699176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::PHINode *RealPHI = Builder.CreatePHI(ResR->getType(), 3, "real_mul_phi"); 700176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines RealPHI->addIncoming(ResR, OrigBB); 701176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines RealPHI->addIncoming(ResR, INaNBB); 702176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines RealPHI->addIncoming(LibCallR, LibCallBB); 703176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm::PHINode *ImagPHI = Builder.CreatePHI(ResI->getType(), 3, "imag_mul_phi"); 704176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ImagPHI->addIncoming(ResI, OrigBB); 705176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ImagPHI->addIncoming(ResI, INaNBB); 706176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ImagPHI->addIncoming(LibCallI, LibCallBB); 707176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return ComplexPairTy(RealPHI, ImagPHI); 708176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 709176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines assert((Op.LHS.second || Op.RHS.second) && 710176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines "At least one operand must be complex!"); 711176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 712176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // If either of the operands is a real rather than a complex, the 713176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // imaginary component is ignored when computing the real component of the 714176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // result. 715176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResR = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 716db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 717176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResI = Op.LHS.second 718176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ? Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il") 719176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines : Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 72087415d2d45224596a96ef02310701797d56b2c19Chris Lattner } else { 721176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines assert(Op.LHS.second && Op.RHS.second && 722176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines "Both operands of integer complex operators must be complex!"); 72387415d2d45224596a96ef02310701797d56b2c19Chris Lattner Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 724176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second, "mul.rr"); 725176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 726db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 72787415d2d45224596a96ef02310701797d56b2c19Chris Lattner Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 72887415d2d45224596a96ef02310701797d56b2c19Chris Lattner Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 729176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 73087415d2d45224596a96ef02310701797d56b2c19Chris Lattner } 7312823c195ee65caf4042dc512c62df811c82dfbc1Chris Lattner return ComplexPairTy(ResR, ResI); 7322823c195ee65caf4042dc512c62df811c82dfbc1Chris Lattner} 7332823c195ee65caf4042dc512c62df811c82dfbc1Chris Lattner 734176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines// See C11 Annex G.5.1 for the semantics of multiplicative operators on complex 735176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines// typed values. 736ab340c22fee7f536d83242411c40e63aa3718987Chris LattnerComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 737ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 738ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 739db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 7403219c5d2d9e3a8a90e0e2ccc91cf49d12c696620Chris Lattner 7413219c5d2d9e3a8a90e0e2ccc91cf49d12c696620Chris Lattner llvm::Value *DSTr, *DSTi; 742176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (LHSr->getType()->isFloatingPointTy()) { 743176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // If we have a complex operand on the RHS, we delegate to a libcall to 744176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // handle all of the complexities and minimize underflow/overflow cases. 745176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // 746176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // FIXME: We would be able to avoid the libcall in many places if we 747176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // supported imaginary types in addition to complex types. 748176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (RHSi) { 749176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines BinOpInfo LibCallOp = Op; 750176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // If LHS was a real, supply a null imaginary part. 751176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!LHSi) 752176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines LibCallOp.LHS.second = llvm::Constant::getNullValue(LHSr->getType()); 753176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 754176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines StringRef LibCallName; 755176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines switch (LHSr->getType()->getTypeID()) { 756176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines default: 757176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines llvm_unreachable("Unsupported floating point type!"); 758176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::HalfTyID: 759176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return EmitComplexBinOpLibCall("__divhc3", LibCallOp); 760176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::FloatTyID: 761176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return EmitComplexBinOpLibCall("__divsc3", LibCallOp); 762176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::DoubleTyID: 763176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return EmitComplexBinOpLibCall("__divdc3", LibCallOp); 764176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::PPC_FP128TyID: 765176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return EmitComplexBinOpLibCall("__divtc3", LibCallOp); 766176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::X86_FP80TyID: 767176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return EmitComplexBinOpLibCall("__divxc3", LibCallOp); 768176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines case llvm::Type::FP128TyID: 769176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines return EmitComplexBinOpLibCall("__divtc3", LibCallOp); 770176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 771176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 772176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines assert(LHSi && "Can have at most one non-complex operand!"); 773db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 774176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines DSTr = Builder.CreateFDiv(LHSr, RHSr); 775176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines DSTi = Builder.CreateFDiv(LHSi, RHSr); 7763219c5d2d9e3a8a90e0e2ccc91cf49d12c696620Chris Lattner } else { 777176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines assert(Op.LHS.second && Op.RHS.second && 778176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines "Both operands of integer complex operators must be complex!"); 77987415d2d45224596a96ef02310701797d56b2c19Chris Lattner // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 780578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr); // a*c 781578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi); // b*d 782578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2); // ac+bd 783db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 784578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr); // c*c 785578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi); // d*d 786578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5); // cc+dd 787db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 788578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr); // b*c 789578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi); // a*d 790578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8); // bc-ad 791db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 7929d232c884ea9872d6555df0fd7359699819bc1f1John McCall if (Op.Ty->castAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { 793578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer DSTr = Builder.CreateUDiv(Tmp3, Tmp6); 794578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer DSTi = Builder.CreateUDiv(Tmp9, Tmp6); 7953219c5d2d9e3a8a90e0e2ccc91cf49d12c696620Chris Lattner } else { 796578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer DSTr = Builder.CreateSDiv(Tmp3, Tmp6); 797578faa837b552403e2002b97fdfbfde14f2448e5Benjamin Kramer DSTi = Builder.CreateSDiv(Tmp9, Tmp6); 7983219c5d2d9e3a8a90e0e2ccc91cf49d12c696620Chris Lattner } 7993219c5d2d9e3a8a90e0e2ccc91cf49d12c696620Chris Lattner } 800db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 8013219c5d2d9e3a8a90e0e2ccc91cf49d12c696620Chris Lattner return ComplexPairTy(DSTr, DSTi); 8023219c5d2d9e3a8a90e0e2ccc91cf49d12c696620Chris Lattner} 8033219c5d2d9e3a8a90e0e2ccc91cf49d12c696620Chris Lattner 804db52dcdae7d2e25565096d07ee74fa307061cc32Mike StumpComplexExprEmitter::BinOpInfo 805ab340c22fee7f536d83242411c40e63aa3718987Chris LattnerComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 8067f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreReal(); 8077f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreImag(); 808ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner BinOpInfo Ops; 809176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (E->getLHS()->getType()->isRealFloatingType()) 810176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Ops.LHS = ComplexPairTy(CGF.EmitScalarExpr(E->getLHS()), nullptr); 811176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines else 812176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Ops.LHS = Visit(E->getLHS()); 813176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (E->getRHS()->getType()->isRealFloatingType()) 814176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Ops.RHS = ComplexPairTy(CGF.EmitScalarExpr(E->getRHS()), nullptr); 815176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines else 816176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines Ops.RHS = Visit(E->getRHS()); 817176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines 818ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner Ops.Ty = E->getType(); 819ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner return Ops; 820ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner} 821ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner 822ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner 823b418d74c11498b7e1044103131e2e3be4d63512eJohn McCallLValue ComplexExprEmitter:: 824b418d74c11498b7e1044103131e2e3be4d63512eJohn McCallEmitCompoundAssignLValue(const CompoundAssignOperator *E, 825b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&), 8260934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman RValue &Val) { 8277f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreReal(); 8287f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreImag(); 829dec0984fce504a39a7f085774fb67cfd9957be58Jeffrey Yasskin QualType LHSTy = E->getLHS()->getType(); 8300e2c34f92f00628d48968dfea096d36381f494cbStephen Hines if (const AtomicType *AT = LHSTy->getAs<AtomicType>()) 8310e2c34f92f00628d48968dfea096d36381f494cbStephen Hines LHSTy = AT->getValueType(); 832ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner 833ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner BinOpInfo OpInfo; 834db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 8357f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // Load the RHS and LHS operands. 8367f79f9be5916c51c35da4f126b7c12596a101607Mike Stump // __block variables need to have the rhs evaluated first, plus this should 837641ca7d01441c34566756744838abb8faf1356aaJohn McCall // improve codegen a little. 838ab3a852ae713189444dcbf75e70accf1e8c2b7f2Eli Friedman OpInfo.Ty = E->getComputationResultType(); 839176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines QualType ComplexElementTy = cast<ComplexType>(OpInfo.Ty)->getElementType(); 840641ca7d01441c34566756744838abb8faf1356aaJohn McCall 841641ca7d01441c34566756744838abb8faf1356aaJohn McCall // The RHS should have been converted to the computation type. 842176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (E->getRHS()->getType()->isRealFloatingType()) { 843176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines assert( 844176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines CGF.getContext() 845176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines .hasSameUnqualifiedType(ComplexElementTy, E->getRHS()->getType())); 846176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines OpInfo.RHS = ComplexPairTy(CGF.EmitScalarExpr(E->getRHS()), nullptr); 847176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } else { 848176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines assert(CGF.getContext() 849176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines .hasSameUnqualifiedType(OpInfo.Ty, E->getRHS()->getType())); 850176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines OpInfo.RHS = Visit(E->getRHS()); 851176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 852651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines 853120bc77f4c9ec281ec5e2d2a856c80cfae18bb57Daniel Dunbar LValue LHS = CGF.EmitLValue(E->getLHS()); 8540e800c9c20d1a658a91096c756c4a4a9e90264fcJohn McCall 8550934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman // Load from the l-value and convert it. 85687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar SourceLocation Loc = E->getExprLoc(); 8570934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman if (LHSTy->isAnyComplexType()) { 85887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar ComplexPairTy LHSVal = EmitLoadOfLValue(LHS, Loc); 85987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar OpInfo.LHS = EmitComplexToComplexCast(LHSVal, LHSTy, OpInfo.Ty, Loc); 8600934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman } else { 86187d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar llvm::Value *LHSVal = CGF.EmitLoadOfScalar(LHS, Loc); 862176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // For floating point real operands we can directly pass the scalar form 863176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines // to the binary operator emission and potentially get more efficient code. 864176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (LHSTy->isRealFloatingType()) { 865176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines if (!CGF.getContext().hasSameUnqualifiedType(ComplexElementTy, LHSTy)) 86687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar LHSVal = CGF.EmitScalarConversion(LHSVal, LHSTy, ComplexElementTy, Loc); 867176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines OpInfo.LHS = ComplexPairTy(LHSVal, nullptr); 868176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } else { 86987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar OpInfo.LHS = EmitScalarToComplexCast(LHSVal, LHSTy, OpInfo.Ty, Loc); 870176edba5311f6eff0cad2631449885ddf4fbc9eaStephen Hines } 8710934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman } 872db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 873ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner // Expand the binary operator. 874ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner ComplexPairTy Result = (this->*Func)(OpInfo); 875db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 8760934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman // Truncate the result and store it into the LHS lvalue. 8770934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman if (LHSTy->isAnyComplexType()) { 87887d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar ComplexPairTy ResVal = 87987d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy, Loc); 8800934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman EmitStoreOfComplex(ResVal, LHS, /*isInit*/ false); 8810934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman Val = RValue::getComplex(ResVal); 8820934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman } else { 8830934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman llvm::Value *ResVal = 88487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar CGF.EmitComplexToScalarConversion(Result, OpInfo.Ty, LHSTy, Loc); 8850934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman CGF.EmitStoreOfScalar(ResVal, LHS, /*isInit*/ false); 8860934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman Val = RValue::get(ResVal); 8870934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman } 888120bc77f4c9ec281ec5e2d2a856c80cfae18bb57Daniel Dunbar 889b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return LHS; 890b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall} 891b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 892b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall// Compound assignments. 893b418d74c11498b7e1044103131e2e3be4d63512eJohn McCallComplexPairTy ComplexExprEmitter:: 894b418d74c11498b7e1044103131e2e3be4d63512eJohn McCallEmitCompoundAssign(const CompoundAssignOperator *E, 895b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 8960934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman RValue Val; 897b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall LValue LV = EmitCompoundAssignLValue(E, Func, Val); 898b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 899b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 9007edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (!CGF.getLangOpts().CPlusPlus) 9010934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman return Val.getComplexVal(); 902b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 903b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If the lvalue is non-volatile, return the computed value of the assignment. 904b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!LV.isVolatileQualified()) 9050934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman return Val.getComplexVal(); 906b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 9074ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return EmitLoadOfLValue(LV, E->getExprLoc()); 908ab340c22fee7f536d83242411c40e63aa3718987Chris Lattner} 9093219c5d2d9e3a8a90e0e2ccc91cf49d12c696620Chris Lattner 910b418d74c11498b7e1044103131e2e3be4d63512eJohn McCallLValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E, 911b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall ComplexPairTy &Val) { 912651f13cea278ec967336033dd032faef0e9fc2ecStephen Hines assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 9136398235d7890a81b785ea5af3b6e66d86bf184ccDouglas Gregor E->getRHS()->getType()) && 9149619662a1d42e2008b865d3459c0677e149dad1bChris Lattner "Invalid assignment"); 915b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall TestAndClearIgnoreReal(); 916b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall TestAndClearIgnoreImag(); 917b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 918cd940a1e13e588a43973cd7ae33b5c33a3062739John McCall // Emit the RHS. __block variables need the RHS evaluated first. 919b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall Val = Visit(E->getRHS()); 920b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 921b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner // Compute the address to store into. 922b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner LValue LHS = CGF.EmitLValue(E->getLHS()); 923db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 924120bc77f4c9ec281ec5e2d2a856c80cfae18bb57Daniel Dunbar // Store the result value into the LHS lvalue. 9259d232c884ea9872d6555df0fd7359699819bc1f1John McCall EmitStoreOfComplex(Val, LHS, /*isInit*/ false); 92642f963dec21ed86f33ba34dc01140f77c7174768Daniel Dunbar 927b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return LHS; 928b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall} 929120bc77f4c9ec281ec5e2d2a856c80cfae18bb57Daniel Dunbar 930b418d74c11498b7e1044103131e2e3be4d63512eJohn McCallComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 931b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall ComplexPairTy Val; 932b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall LValue LV = EmitBinAssignLValue(E, Val); 933b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 934b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // The result of an assignment in C is the assigned r-value. 9357edf9e38b91917b661277601c0e448eef0eb2b56Richard Smith if (!CGF.getLangOpts().CPlusPlus) 936b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return Val; 937b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 938b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall // If the lvalue is non-volatile, return the computed value of the assignment. 939b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall if (!LV.isVolatileQualified()) 940b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return Val; 941b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall 9424ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return EmitLoadOfLValue(LV, E->getExprLoc()); 943b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner} 944b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 945756a4d88457aebb6c154a4cbb5d595fdb2e0899dChris LattnerComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 9462a41637a995affa1563f4d82a8b026e326a2faa0John McCall CGF.EmitIgnoredExpr(E->getLHS()); 947756a4d88457aebb6c154a4cbb5d595fdb2e0899dChris Lattner return Visit(E->getRHS()); 948756a4d88457aebb6c154a4cbb5d595fdb2e0899dChris Lattner} 949b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 950b6ef18a2b06d6760459e1756a61f79ff496cee19Chris LattnerComplexPairTy ComplexExprEmitter:: 95156ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCallVisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 9527f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreReal(); 9537f79f9be5916c51c35da4f126b7c12596a101607Mike Stump TestAndClearIgnoreImag(); 9549615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 9559615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 9569615ecb44f549ae9fa2b4db6ff46bc78befbf62cDaniel Dunbar llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 957db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 95856ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall // Bind the common expression if necessary. 959d97927d69b277120f8d403580c44acd84907d7b4Eli Friedman CodeGenFunction::OpaqueValueMapping binding(CGF, E); 960150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall 961b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar 96256ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall CodeGenFunction::ConditionalEvaluation eval(CGF); 963b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock, 964b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar CGF.getProfileCount(E)); 965db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 966150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 967b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner CGF.EmitBlock(LHSBlock); 968b6d6993e6e6d3daf4d9876794254d20a134e37c2Pirama Arumuga Nainar CGF.incrementProfileCounter(E); 969aa3b57ee9e36a805371e2a543383225cdd2a5d83Fariborz Jahanian ComplexPairTy LHS = Visit(E->getTrueExpr()); 9705083a536971419786b5f7a5fbadfc228cad5c658Chris Lattner LHSBlock = Builder.GetInsertBlock(); 971d57a871339c7c98d58d93108b806f59bdf4e13e2Daniel Dunbar CGF.EmitBranch(ContBlock); 972150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 973db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 974150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.begin(CGF); 975b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner CGF.EmitBlock(RHSBlock); 97656ca35d396d8692c384c785f9aeebcf22563fe1eJohn McCall ComplexPairTy RHS = Visit(E->getFalseExpr()); 9775083a536971419786b5f7a5fbadfc228cad5c658Chris Lattner RHSBlock = Builder.GetInsertBlock(); 978b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner CGF.EmitBlock(ContBlock); 979150b462afc7a713edd19bcbbbb22381fe060d4f5John McCall eval.end(CGF); 980db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 981b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner // Create a PHI node for the real part. 982bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r"); 983b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner RealPN->addIncoming(LHS.first, LHSBlock); 984b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner RealPN->addIncoming(RHS.first, RHSBlock); 985b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 986b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner // Create a PHI node for the imaginary part. 987bbf3bacb3e0c1ebb3e8a4a8b1330404a7e379315Jay Foad llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i"); 988b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner ImagPN->addIncoming(LHS.second, LHSBlock); 989b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner ImagPN->addIncoming(RHS.second, RHSBlock); 990db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 991b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner return ComplexPairTy(RealPN, ImagPN); 992b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner} 993b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 994d0b1203b1c982be34a56199c59c53ae15a953667Chris LattnerComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 995a5e660188a3c654cf0c88ed1093b28207e870b2bEli Friedman return Visit(E->getChosenSubExpr()); 996d0b1203b1c982be34a56199c59c53ae15a953667Chris Lattner} 997d0b1203b1c982be34a56199c59c53ae15a953667Chris Lattner 998c4777f1928913423234d8d534898f22e9792ae52Eli FriedmanComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 9997f79f9be5916c51c35da4f126b7c12596a101607Mike Stump bool Ignore = TestAndClearIgnoreReal(); 10007f79f9be5916c51c35da4f126b7c12596a101607Mike Stump (void)Ignore; 10017f79f9be5916c51c35da4f126b7c12596a101607Mike Stump assert (Ignore == false && "init list ignored"); 10027f79f9be5916c51c35da4f126b7c12596a101607Mike Stump Ignore = TestAndClearIgnoreImag(); 10037f79f9be5916c51c35da4f126b7c12596a101607Mike Stump (void)Ignore; 10047f79f9be5916c51c35da4f126b7c12596a101607Mike Stump assert (Ignore == false && "init list ignored"); 10050c706c29f20b6fa36759fa41333b9c3ec0bd2969Eli Friedman 10060c706c29f20b6fa36759fa41333b9c3ec0bd2969Eli Friedman if (E->getNumInits() == 2) { 10070c706c29f20b6fa36759fa41333b9c3ec0bd2969Eli Friedman llvm::Value *Real = CGF.EmitScalarExpr(E->getInit(0)); 10080c706c29f20b6fa36759fa41333b9c3ec0bd2969Eli Friedman llvm::Value *Imag = CGF.EmitScalarExpr(E->getInit(1)); 10090c706c29f20b6fa36759fa41333b9c3ec0bd2969Eli Friedman return ComplexPairTy(Real, Imag); 10100c706c29f20b6fa36759fa41333b9c3ec0bd2969Eli Friedman } else if (E->getNumInits() == 1) { 1011c4777f1928913423234d8d534898f22e9792ae52Eli Friedman return Visit(E->getInit(0)); 10120c706c29f20b6fa36759fa41333b9c3ec0bd2969Eli Friedman } 1013c4777f1928913423234d8d534898f22e9792ae52Eli Friedman 1014c4777f1928913423234d8d534898f22e9792ae52Eli Friedman // Empty init list intializes to null 10150c706c29f20b6fa36759fa41333b9c3ec0bd2969Eli Friedman assert(E->getNumInits() == 0 && "Unexpected number of inits"); 10169d232c884ea9872d6555df0fd7359699819bc1f1John McCall QualType Ty = E->getType()->castAs<ComplexType>()->getElementType(); 10172acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type* LTy = CGF.ConvertType(Ty); 1018c9c88b4159791c48e486ca94e3743b5979e2b7a6Owen Anderson llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 1019c4777f1928913423234d8d534898f22e9792ae52Eli Friedman return ComplexPairTy(zeroConstant, zeroConstant); 1020c4777f1928913423234d8d534898f22e9792ae52Eli Friedman} 1021c4777f1928913423234d8d534898f22e9792ae52Eli Friedman 10224e484b8134c7eaeced03be7e4e0f7349def9b355Daniel DunbarComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { 102387d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Address ArgValue = Address::invalid(); 102487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar Address ArgPtr = CGF.EmitVAArg(E, ArgValue); 10254e484b8134c7eaeced03be7e4e0f7349def9b355Daniel Dunbar 102687d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar if (!ArgPtr.isValid()) { 10274e484b8134c7eaeced03be7e4e0f7349def9b355Daniel Dunbar CGF.ErrorUnsupported(E, "complex va_arg expression"); 10282acc6e3feda5e4f7d9009bdcf8b1cd777fecfe2dChris Lattner llvm::Type *EltTy = 10299d232c884ea9872d6555df0fd7359699819bc1f1John McCall CGF.ConvertType(E->getType()->castAs<ComplexType>()->getElementType()); 10304e484b8134c7eaeced03be7e4e0f7349def9b355Daniel Dunbar llvm::Value *U = llvm::UndefValue::get(EltTy); 10314e484b8134c7eaeced03be7e4e0f7349def9b355Daniel Dunbar return ComplexPairTy(U, U); 10324e484b8134c7eaeced03be7e4e0f7349def9b355Daniel Dunbar } 10334e484b8134c7eaeced03be7e4e0f7349def9b355Daniel Dunbar 103487d948ecccffea9e9e37d0d053b246e2d6d6c47bPirama Arumuga Nainar return EmitLoadOfLValue(CGF.MakeAddrLValue(ArgPtr, E->getType()), 10354ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky E->getExprLoc()); 10364e484b8134c7eaeced03be7e4e0f7349def9b355Daniel Dunbar} 10374e484b8134c7eaeced03be7e4e0f7349def9b355Daniel Dunbar 1038b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner//===----------------------------------------------------------------------===// 1039b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner// Entry Point into this File 1040b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner//===----------------------------------------------------------------------===// 1041b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 1042b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner/// EmitComplexExpr - Emit the computation of the specified expression of 1043b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner/// complex type, ignoring the result. 10447f79f9be5916c51c35da4f126b7c12596a101607Mike StumpComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, 1045b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall bool IgnoreImag) { 10469d232c884ea9872d6555df0fd7359699819bc1f1John McCall assert(E && getComplexType(E->getType()) && 1047b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner "Invalid complex expression to emit"); 1048db52dcdae7d2e25565096d07ee74fa307061cc32Mike Stump 1049b418d74c11498b7e1044103131e2e3be4d63512eJohn McCall return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag) 10500e2c34f92f00628d48968dfea096d36381f494cbStephen Hines .Visit(const_cast<Expr *>(E)); 1051b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner} 1052b6ef18a2b06d6760459e1756a61f79ff496cee19Chris Lattner 10539d232c884ea9872d6555df0fd7359699819bc1f1John McCallvoid CodeGenFunction::EmitComplexExprIntoLValue(const Expr *E, LValue dest, 10549d232c884ea9872d6555df0fd7359699819bc1f1John McCall bool isInit) { 10559d232c884ea9872d6555df0fd7359699819bc1f1John McCall assert(E && getComplexType(E->getType()) && 105623b1cdb0b5e089468bb8475b8ec9287af67b4b59Chris Lattner "Invalid complex expression to emit"); 105723b1cdb0b5e089468bb8475b8ec9287af67b4b59Chris Lattner ComplexExprEmitter Emitter(*this); 105823b1cdb0b5e089468bb8475b8ec9287af67b4b59Chris Lattner ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 10599d232c884ea9872d6555df0fd7359699819bc1f1John McCall Emitter.EmitStoreOfComplex(Val, dest, isInit); 106023b1cdb0b5e089468bb8475b8ec9287af67b4b59Chris Lattner} 10619b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner 10629d232c884ea9872d6555df0fd7359699819bc1f1John McCall/// EmitStoreOfComplex - Store a complex number into the specified l-value. 10639d232c884ea9872d6555df0fd7359699819bc1f1John McCallvoid CodeGenFunction::EmitStoreOfComplex(ComplexPairTy V, LValue dest, 10649d232c884ea9872d6555df0fd7359699819bc1f1John McCall bool isInit) { 10659d232c884ea9872d6555df0fd7359699819bc1f1John McCall ComplexExprEmitter(*this).EmitStoreOfComplex(V, dest, isInit); 10667f8ea5c5b3a6a4332a841eefdd86b0726722ea7bDaniel Dunbar} 10677f8ea5c5b3a6a4332a841eefdd86b0726722ea7bDaniel Dunbar 10689d232c884ea9872d6555df0fd7359699819bc1f1John McCall/// EmitLoadOfComplex - Load a complex number from the specified address. 10694ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick LewyckyComplexPairTy CodeGenFunction::EmitLoadOfComplex(LValue src, 10704ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky SourceLocation loc) { 10714ee7dc2369c1f0257a73b2e83a7d38fdebdd9176Nick Lewycky return ComplexExprEmitter(*this).EmitLoadOfLValue(src, loc); 10729b65551d0b387a7597fb39356a4d8ef10046445eChris Lattner} 107383ce9d4a552987d34cbd500e983db8d770232379John McCall 107483ce9d4a552987d34cbd500e983db8d770232379John McCallLValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) { 10752a41637a995affa1563f4d82a8b026e326a2faa0John McCall assert(E->getOpcode() == BO_Assign); 107683ce9d4a552987d34cbd500e983db8d770232379John McCall ComplexPairTy Val; // ignored 10772a41637a995affa1563f4d82a8b026e326a2faa0John McCall return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val); 10782a41637a995affa1563f4d82a8b026e326a2faa0John McCall} 107983ce9d4a552987d34cbd500e983db8d770232379John McCall 10800934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedmantypedef ComplexPairTy (ComplexExprEmitter::*CompoundFunc)( 10810934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman const ComplexExprEmitter::BinOpInfo &); 108283ce9d4a552987d34cbd500e983db8d770232379John McCall 10830934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedmanstatic CompoundFunc getComplexOp(BinaryOperatorKind Op) { 10840934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman switch (Op) { 10850934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman case BO_MulAssign: return &ComplexExprEmitter::EmitBinMul; 10860934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman case BO_DivAssign: return &ComplexExprEmitter::EmitBinDiv; 10870934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman case BO_SubAssign: return &ComplexExprEmitter::EmitBinSub; 10880934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman case BO_AddAssign: return &ComplexExprEmitter::EmitBinAdd; 108983ce9d4a552987d34cbd500e983db8d770232379John McCall default: 109083ce9d4a552987d34cbd500e983db8d770232379John McCall llvm_unreachable("unexpected complex compound assignment"); 109183ce9d4a552987d34cbd500e983db8d770232379John McCall } 10920934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman} 109383ce9d4a552987d34cbd500e983db8d770232379John McCall 10940934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli FriedmanLValue CodeGenFunction:: 10950934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli FriedmanEmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) { 10960934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman CompoundFunc Op = getComplexOp(E->getOpcode()); 10970934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman RValue Val; 10982a41637a995affa1563f4d82a8b026e326a2faa0John McCall return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); 109983ce9d4a552987d34cbd500e983db8d770232379John McCall} 11000934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman 11010934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli FriedmanLValue CodeGenFunction:: 11020e2c34f92f00628d48968dfea096d36381f494cbStephen HinesEmitScalarCompoundAssignWithComplex(const CompoundAssignOperator *E, 11030e2c34f92f00628d48968dfea096d36381f494cbStephen Hines llvm::Value *&Result) { 11040934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman CompoundFunc Op = getComplexOp(E->getOpcode()); 11050934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman RValue Val; 11060934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman LValue Ret = ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); 11070934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman Result = Val.getScalarVal(); 11080934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman return Ret; 11090934e18b620ecaa6c7ec18ba5c4286b6122d6fb8Eli Friedman} 1110