CGExprComplex.cpp revision d295b8229c119e0f2b085874249437347084e320
1//===--- CGExprComplex.cpp - Emit LLVM Code for Complex Exprs -------------===// 2// 3// The LLVM Compiler Infrastructure 4// 5// This file is distributed under the University of Illinois Open Source 6// License. See LICENSE.TXT for details. 7// 8//===----------------------------------------------------------------------===// 9// 10// This contains code to emit Expr nodes with complex types as LLVM code. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CodeGenFunction.h" 15#include "CodeGenModule.h" 16#include "clang/AST/ASTContext.h" 17#include "clang/AST/StmtVisitor.h" 18#include "llvm/Constants.h" 19#include "llvm/Function.h" 20#include "llvm/ADT/SmallString.h" 21using namespace clang; 22using namespace CodeGen; 23 24//===----------------------------------------------------------------------===// 25// Complex Expression Emitter 26//===----------------------------------------------------------------------===// 27 28typedef CodeGenFunction::ComplexPairTy ComplexPairTy; 29 30namespace { 31class ComplexExprEmitter 32 : public StmtVisitor<ComplexExprEmitter, ComplexPairTy> { 33 CodeGenFunction &CGF; 34 CGBuilderTy &Builder; 35 // True is we should ignore the value of a 36 bool IgnoreReal; 37 bool IgnoreImag; 38public: 39 ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false) 40 : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii) { 41 } 42 43 44 //===--------------------------------------------------------------------===// 45 // Utilities 46 //===--------------------------------------------------------------------===// 47 48 bool TestAndClearIgnoreReal() { 49 bool I = IgnoreReal; 50 IgnoreReal = false; 51 return I; 52 } 53 bool TestAndClearIgnoreImag() { 54 bool I = IgnoreImag; 55 IgnoreImag = false; 56 return I; 57 } 58 59 /// EmitLoadOfLValue - Given an expression with complex type that represents a 60 /// value l-value, this method emits the address of the l-value, then loads 61 /// and returns the result. 62 ComplexPairTy EmitLoadOfLValue(const Expr *E) { 63 return EmitLoadOfLValue(CGF.EmitLValue(E)); 64 } 65 66 ComplexPairTy EmitLoadOfLValue(LValue LV) { 67 if (LV.isSimple()) 68 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 69 70 assert(LV.isPropertyRef() && "Unknown LValue type!"); 71 return CGF.EmitLoadOfPropertyRefLValue(LV).getComplexVal(); 72 } 73 74 /// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load 75 /// the real and imaginary pieces. 76 ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr, bool isVolatile); 77 78 /// EmitStoreThroughLValue - Given an l-value of complex type, store 79 /// a complex number into it. 80 void EmitStoreThroughLValue(ComplexPairTy Val, LValue LV) { 81 if (LV.isSimple()) 82 return EmitStoreOfComplex(Val, LV.getAddress(), LV.isVolatileQualified()); 83 84 assert(LV.isPropertyRef() && "Unknown LValue type!"); 85 CGF.EmitStoreThroughPropertyRefLValue(RValue::getComplex(Val), LV); 86 } 87 88 /// EmitStoreOfComplex - Store the specified real/imag parts into the 89 /// specified value pointer. 90 void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr, bool isVol); 91 92 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 93 ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType, 94 QualType DestType); 95 96 //===--------------------------------------------------------------------===// 97 // Visitor Methods 98 //===--------------------------------------------------------------------===// 99 100 ComplexPairTy Visit(Expr *E) { 101 return StmtVisitor<ComplexExprEmitter, ComplexPairTy>::Visit(E); 102 } 103 104 ComplexPairTy VisitStmt(Stmt *S) { 105 S->dump(CGF.getContext().getSourceManager()); 106 assert(0 && "Stmt can't have complex result type!"); 107 return ComplexPairTy(); 108 } 109 ComplexPairTy VisitExpr(Expr *S); 110 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());} 111 ComplexPairTy VisitGenericSelectionExpr(GenericSelectionExpr *GE) { 112 return Visit(GE->getResultExpr()); 113 } 114 ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL); 115 ComplexPairTy 116 VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) { 117 return Visit(PE->getReplacement()); 118 } 119 120 // l-values. 121 ComplexPairTy VisitDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); } 122 ComplexPairTy VisitBlockDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); } 123 ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 124 return EmitLoadOfLValue(E); 125 } 126 ComplexPairTy VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 127 assert(E->getObjectKind() == OK_Ordinary); 128 return EmitLoadOfLValue(E); 129 } 130 ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) { 131 return CGF.EmitObjCMessageExpr(E).getComplexVal(); 132 } 133 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); } 134 ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); } 135 ComplexPairTy VisitOpaqueValueExpr(OpaqueValueExpr *E) { 136 if (E->isGLValue()) 137 return EmitLoadOfLValue(CGF.getOpaqueLValueMapping(E)); 138 return CGF.getOpaqueRValueMapping(E).getComplexVal(); 139 } 140 141 // FIXME: CompoundLiteralExpr 142 143 ComplexPairTy EmitCast(CastExpr::CastKind CK, Expr *Op, QualType DestTy); 144 ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) { 145 // Unlike for scalars, we don't have to worry about function->ptr demotion 146 // here. 147 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); 148 } 149 ComplexPairTy VisitCastExpr(CastExpr *E) { 150 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); 151 } 152 ComplexPairTy VisitCallExpr(const CallExpr *E); 153 ComplexPairTy VisitStmtExpr(const StmtExpr *E); 154 155 // Operators. 156 ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E, 157 bool isInc, bool isPre) { 158 LValue LV = CGF.EmitLValue(E->getSubExpr()); 159 return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre); 160 } 161 ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) { 162 return VisitPrePostIncDec(E, false, false); 163 } 164 ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) { 165 return VisitPrePostIncDec(E, true, false); 166 } 167 ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) { 168 return VisitPrePostIncDec(E, false, true); 169 } 170 ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) { 171 return VisitPrePostIncDec(E, true, true); 172 } 173 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 174 ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) { 175 TestAndClearIgnoreReal(); 176 TestAndClearIgnoreImag(); 177 return Visit(E->getSubExpr()); 178 } 179 ComplexPairTy VisitUnaryMinus (const UnaryOperator *E); 180 ComplexPairTy VisitUnaryNot (const UnaryOperator *E); 181 // LNot,Real,Imag never return complex. 182 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) { 183 return Visit(E->getSubExpr()); 184 } 185 ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 186 return Visit(DAE->getExpr()); 187 } 188 ComplexPairTy VisitExprWithCleanups(ExprWithCleanups *E) { 189 return CGF.EmitExprWithCleanups(E).getComplexVal(); 190 } 191 ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 192 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 193 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType(); 194 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 195 return ComplexPairTy(Null, Null); 196 } 197 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 198 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 199 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType(); 200 llvm::Constant *Null = 201 llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 202 return ComplexPairTy(Null, Null); 203 } 204 205 struct BinOpInfo { 206 ComplexPairTy LHS; 207 ComplexPairTy RHS; 208 QualType Ty; // Computation Type. 209 }; 210 211 BinOpInfo EmitBinOps(const BinaryOperator *E); 212 LValue EmitCompoundAssignLValue(const CompoundAssignOperator *E, 213 ComplexPairTy (ComplexExprEmitter::*Func) 214 (const BinOpInfo &), 215 ComplexPairTy &Val); 216 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E, 217 ComplexPairTy (ComplexExprEmitter::*Func) 218 (const BinOpInfo &)); 219 220 ComplexPairTy EmitBinAdd(const BinOpInfo &Op); 221 ComplexPairTy EmitBinSub(const BinOpInfo &Op); 222 ComplexPairTy EmitBinMul(const BinOpInfo &Op); 223 ComplexPairTy EmitBinDiv(const BinOpInfo &Op); 224 225 ComplexPairTy VisitBinAdd(const BinaryOperator *E) { 226 return EmitBinAdd(EmitBinOps(E)); 227 } 228 ComplexPairTy VisitBinSub(const BinaryOperator *E) { 229 return EmitBinSub(EmitBinOps(E)); 230 } 231 ComplexPairTy VisitBinMul(const BinaryOperator *E) { 232 return EmitBinMul(EmitBinOps(E)); 233 } 234 ComplexPairTy VisitBinDiv(const BinaryOperator *E) { 235 return EmitBinDiv(EmitBinOps(E)); 236 } 237 238 // Compound assignments. 239 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) { 240 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd); 241 } 242 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) { 243 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub); 244 } 245 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) { 246 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul); 247 } 248 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) { 249 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv); 250 } 251 252 // GCC rejects rem/and/or/xor for integer complex. 253 // Logical and/or always return int, never complex. 254 255 // No comparisons produce a complex result. 256 257 LValue EmitBinAssignLValue(const BinaryOperator *E, 258 ComplexPairTy &Val); 259 ComplexPairTy VisitBinAssign (const BinaryOperator *E); 260 ComplexPairTy VisitBinComma (const BinaryOperator *E); 261 262 263 ComplexPairTy 264 VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO); 265 ComplexPairTy VisitChooseExpr(ChooseExpr *CE); 266 267 ComplexPairTy VisitInitListExpr(InitListExpr *E); 268 269 ComplexPairTy VisitVAArgExpr(VAArgExpr *E); 270}; 271} // end anonymous namespace. 272 273//===----------------------------------------------------------------------===// 274// Utilities 275//===----------------------------------------------------------------------===// 276 277/// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to 278/// load the real and imaginary pieces, returning them as Real/Imag. 279ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr, 280 bool isVolatile) { 281 llvm::Value *Real=0, *Imag=0; 282 283 if (!IgnoreReal || isVolatile) { 284 llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0, 285 SrcPtr->getName() + ".realp"); 286 Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr->getName() + ".real"); 287 } 288 289 if (!IgnoreImag || isVolatile) { 290 llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1, 291 SrcPtr->getName() + ".imagp"); 292 Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr->getName() + ".imag"); 293 } 294 return ComplexPairTy(Real, Imag); 295} 296 297/// EmitStoreOfComplex - Store the specified real/imag parts into the 298/// specified value pointer. 299void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr, 300 bool isVolatile) { 301 llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real"); 302 llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag"); 303 304 Builder.CreateStore(Val.first, RealPtr, isVolatile); 305 Builder.CreateStore(Val.second, ImagPtr, isVolatile); 306} 307 308 309 310//===----------------------------------------------------------------------===// 311// Visitor Methods 312//===----------------------------------------------------------------------===// 313 314ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) { 315 CGF.ErrorUnsupported(E, "complex expression"); 316 llvm::Type *EltTy = 317 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 318 llvm::Value *U = llvm::UndefValue::get(EltTy); 319 return ComplexPairTy(U, U); 320} 321 322ComplexPairTy ComplexExprEmitter:: 323VisitImaginaryLiteral(const ImaginaryLiteral *IL) { 324 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); 325 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); 326} 327 328 329ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { 330 if (E->getCallReturnType()->isReferenceType()) 331 return EmitLoadOfLValue(E); 332 333 return CGF.EmitCallExpr(E).getComplexVal(); 334} 335 336ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) { 337 CodeGenFunction::StmtExprEvaluation eval(CGF); 338 return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal(); 339} 340 341/// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 342ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val, 343 QualType SrcType, 344 QualType DestType) { 345 // Get the src/dest element type. 346 SrcType = SrcType->getAs<ComplexType>()->getElementType(); 347 DestType = DestType->getAs<ComplexType>()->getElementType(); 348 349 // C99 6.3.1.6: When a value of complex type is converted to another 350 // complex type, both the real and imaginary parts follow the conversion 351 // rules for the corresponding real types. 352 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType); 353 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType); 354 return Val; 355} 356 357ComplexPairTy ComplexExprEmitter::EmitCast(CastExpr::CastKind CK, Expr *Op, 358 QualType DestTy) { 359 switch (CK) { 360 case CK_Dependent: llvm_unreachable("dependent cast kind in IR gen!"); 361 362 case CK_GetObjCProperty: { 363 LValue LV = CGF.EmitLValue(Op); 364 assert(LV.isPropertyRef() && "Unknown LValue type!"); 365 return CGF.EmitLoadOfPropertyRefLValue(LV).getComplexVal(); 366 } 367 368 case CK_NoOp: 369 case CK_LValueToRValue: 370 case CK_UserDefinedConversion: 371 return Visit(Op); 372 373 case CK_LValueBitCast: { 374 llvm::Value *V = CGF.EmitLValue(Op).getAddress(); 375 V = Builder.CreateBitCast(V, 376 CGF.ConvertType(CGF.getContext().getPointerType(DestTy))); 377 // FIXME: Are the qualifiers correct here? 378 return EmitLoadOfComplex(V, DestTy.isVolatileQualified()); 379 } 380 381 case CK_BitCast: 382 case CK_BaseToDerived: 383 case CK_DerivedToBase: 384 case CK_UncheckedDerivedToBase: 385 case CK_Dynamic: 386 case CK_ToUnion: 387 case CK_ArrayToPointerDecay: 388 case CK_FunctionToPointerDecay: 389 case CK_NullToPointer: 390 case CK_NullToMemberPointer: 391 case CK_BaseToDerivedMemberPointer: 392 case CK_DerivedToBaseMemberPointer: 393 case CK_MemberPointerToBoolean: 394 case CK_ConstructorConversion: 395 case CK_IntegralToPointer: 396 case CK_PointerToIntegral: 397 case CK_PointerToBoolean: 398 case CK_ToVoid: 399 case CK_VectorSplat: 400 case CK_IntegralCast: 401 case CK_IntegralToBoolean: 402 case CK_IntegralToFloating: 403 case CK_FloatingToIntegral: 404 case CK_FloatingToBoolean: 405 case CK_FloatingCast: 406 case CK_AnyPointerToObjCPointerCast: 407 case CK_AnyPointerToBlockPointerCast: 408 case CK_ObjCObjectLValueCast: 409 case CK_FloatingComplexToReal: 410 case CK_FloatingComplexToBoolean: 411 case CK_IntegralComplexToReal: 412 case CK_IntegralComplexToBoolean: 413 case CK_ObjCProduceObject: 414 case CK_ObjCConsumeObject: 415 case CK_ObjCReclaimReturnedObject: 416 llvm_unreachable("invalid cast kind for complex value"); 417 418 case CK_FloatingRealToComplex: 419 case CK_IntegralRealToComplex: { 420 llvm::Value *Elt = CGF.EmitScalarExpr(Op); 421 422 // Convert the input element to the element type of the complex. 423 DestTy = DestTy->getAs<ComplexType>()->getElementType(); 424 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy); 425 426 // Return (realval, 0). 427 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType())); 428 } 429 430 case CK_FloatingComplexCast: 431 case CK_FloatingComplexToIntegralComplex: 432 case CK_IntegralComplexCast: 433 case CK_IntegralComplexToFloatingComplex: 434 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy); 435 } 436 437 llvm_unreachable("unknown cast resulting in complex value"); 438} 439 440ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 441 TestAndClearIgnoreReal(); 442 TestAndClearIgnoreImag(); 443 ComplexPairTy Op = Visit(E->getSubExpr()); 444 445 llvm::Value *ResR, *ResI; 446 if (Op.first->getType()->isFloatingPointTy()) { 447 ResR = Builder.CreateFNeg(Op.first, "neg.r"); 448 ResI = Builder.CreateFNeg(Op.second, "neg.i"); 449 } else { 450 ResR = Builder.CreateNeg(Op.first, "neg.r"); 451 ResI = Builder.CreateNeg(Op.second, "neg.i"); 452 } 453 return ComplexPairTy(ResR, ResI); 454} 455 456ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 457 TestAndClearIgnoreReal(); 458 TestAndClearIgnoreImag(); 459 // ~(a+ib) = a + i*-b 460 ComplexPairTy Op = Visit(E->getSubExpr()); 461 llvm::Value *ResI; 462 if (Op.second->getType()->isFloatingPointTy()) 463 ResI = Builder.CreateFNeg(Op.second, "conj.i"); 464 else 465 ResI = Builder.CreateNeg(Op.second, "conj.i"); 466 467 return ComplexPairTy(Op.first, ResI); 468} 469 470ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 471 llvm::Value *ResR, *ResI; 472 473 if (Op.LHS.first->getType()->isFloatingPointTy()) { 474 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r"); 475 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i"); 476 } else { 477 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 478 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 479 } 480 return ComplexPairTy(ResR, ResI); 481} 482 483ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 484 llvm::Value *ResR, *ResI; 485 if (Op.LHS.first->getType()->isFloatingPointTy()) { 486 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r"); 487 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i"); 488 } else { 489 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 490 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 491 } 492 return ComplexPairTy(ResR, ResI); 493} 494 495 496ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 497 using llvm::Value; 498 Value *ResR, *ResI; 499 500 if (Op.LHS.first->getType()->isFloatingPointTy()) { 501 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 502 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 503 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r"); 504 505 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il"); 506 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 507 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i"); 508 } else { 509 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 510 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 511 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 512 513 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 514 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 515 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 516 } 517 return ComplexPairTy(ResR, ResI); 518} 519 520ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 521 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 522 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 523 524 525 llvm::Value *DSTr, *DSTi; 526 if (Op.LHS.first->getType()->isFloatingPointTy()) { 527 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 528 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr, "tmp"); // a*c 529 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi, "tmp"); // b*d 530 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2, "tmp"); // ac+bd 531 532 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr, "tmp"); // c*c 533 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi, "tmp"); // d*d 534 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5, "tmp"); // cc+dd 535 536 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr, "tmp"); // b*c 537 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi, "tmp"); // a*d 538 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8, "tmp"); // bc-ad 539 540 DSTr = Builder.CreateFDiv(Tmp3, Tmp6, "tmp"); 541 DSTi = Builder.CreateFDiv(Tmp9, Tmp6, "tmp"); 542 } else { 543 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 544 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr, "tmp"); // a*c 545 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi, "tmp"); // b*d 546 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2, "tmp"); // ac+bd 547 548 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr, "tmp"); // c*c 549 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi, "tmp"); // d*d 550 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5, "tmp"); // cc+dd 551 552 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr, "tmp"); // b*c 553 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi, "tmp"); // a*d 554 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8, "tmp"); // bc-ad 555 556 if (Op.Ty->getAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { 557 DSTr = Builder.CreateUDiv(Tmp3, Tmp6, "tmp"); 558 DSTi = Builder.CreateUDiv(Tmp9, Tmp6, "tmp"); 559 } else { 560 DSTr = Builder.CreateSDiv(Tmp3, Tmp6, "tmp"); 561 DSTi = Builder.CreateSDiv(Tmp9, Tmp6, "tmp"); 562 } 563 } 564 565 return ComplexPairTy(DSTr, DSTi); 566} 567 568ComplexExprEmitter::BinOpInfo 569ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 570 TestAndClearIgnoreReal(); 571 TestAndClearIgnoreImag(); 572 BinOpInfo Ops; 573 Ops.LHS = Visit(E->getLHS()); 574 Ops.RHS = Visit(E->getRHS()); 575 Ops.Ty = E->getType(); 576 return Ops; 577} 578 579 580LValue ComplexExprEmitter:: 581EmitCompoundAssignLValue(const CompoundAssignOperator *E, 582 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&), 583 ComplexPairTy &Val) { 584 TestAndClearIgnoreReal(); 585 TestAndClearIgnoreImag(); 586 QualType LHSTy = E->getLHS()->getType(); 587 588 BinOpInfo OpInfo; 589 590 // Load the RHS and LHS operands. 591 // __block variables need to have the rhs evaluated first, plus this should 592 // improve codegen a little. 593 OpInfo.Ty = E->getComputationResultType(); 594 595 // The RHS should have been converted to the computation type. 596 assert(OpInfo.Ty->isAnyComplexType()); 597 assert(CGF.getContext().hasSameUnqualifiedType(OpInfo.Ty, 598 E->getRHS()->getType())); 599 OpInfo.RHS = Visit(E->getRHS()); 600 601 LValue LHS = CGF.EmitLValue(E->getLHS()); 602 603 // Load from the l-value. 604 ComplexPairTy LHSComplexPair = EmitLoadOfLValue(LHS); 605 606 OpInfo.LHS = EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty); 607 608 // Expand the binary operator. 609 ComplexPairTy Result = (this->*Func)(OpInfo); 610 611 // Truncate the result back to the LHS type. 612 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy); 613 Val = Result; 614 615 // Store the result value into the LHS lvalue. 616 EmitStoreThroughLValue(Result, LHS); 617 618 return LHS; 619} 620 621// Compound assignments. 622ComplexPairTy ComplexExprEmitter:: 623EmitCompoundAssign(const CompoundAssignOperator *E, 624 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 625 ComplexPairTy Val; 626 LValue LV = EmitCompoundAssignLValue(E, Func, Val); 627 628 // The result of an assignment in C is the assigned r-value. 629 if (!CGF.getContext().getLangOptions().CPlusPlus) 630 return Val; 631 632 // Objective-C property assignment never reloads the value following a store. 633 if (LV.isPropertyRef()) 634 return Val; 635 636 // If the lvalue is non-volatile, return the computed value of the assignment. 637 if (!LV.isVolatileQualified()) 638 return Val; 639 640 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 641} 642 643LValue ComplexExprEmitter::EmitBinAssignLValue(const BinaryOperator *E, 644 ComplexPairTy &Val) { 645 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 646 E->getRHS()->getType()) && 647 "Invalid assignment"); 648 TestAndClearIgnoreReal(); 649 TestAndClearIgnoreImag(); 650 651 // Emit the RHS. __block variables need the RHS evaluated first. 652 Val = Visit(E->getRHS()); 653 654 // Compute the address to store into. 655 LValue LHS = CGF.EmitLValue(E->getLHS()); 656 657 // Store the result value into the LHS lvalue. 658 EmitStoreThroughLValue(Val, LHS); 659 660 return LHS; 661} 662 663ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 664 ComplexPairTy Val; 665 LValue LV = EmitBinAssignLValue(E, Val); 666 667 // The result of an assignment in C is the assigned r-value. 668 if (!CGF.getContext().getLangOptions().CPlusPlus) 669 return Val; 670 671 // Objective-C property assignment never reloads the value following a store. 672 if (LV.isPropertyRef()) 673 return Val; 674 675 // If the lvalue is non-volatile, return the computed value of the assignment. 676 if (!LV.isVolatileQualified()) 677 return Val; 678 679 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 680} 681 682ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 683 CGF.EmitIgnoredExpr(E->getLHS()); 684 return Visit(E->getRHS()); 685} 686 687ComplexPairTy ComplexExprEmitter:: 688VisitAbstractConditionalOperator(const AbstractConditionalOperator *E) { 689 TestAndClearIgnoreReal(); 690 TestAndClearIgnoreImag(); 691 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 692 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 693 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 694 695 // Bind the common expression if necessary. 696 CodeGenFunction::OpaqueValueMapping binding(CGF, E); 697 698 CodeGenFunction::ConditionalEvaluation eval(CGF); 699 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 700 701 eval.begin(CGF); 702 CGF.EmitBlock(LHSBlock); 703 ComplexPairTy LHS = Visit(E->getTrueExpr()); 704 LHSBlock = Builder.GetInsertBlock(); 705 CGF.EmitBranch(ContBlock); 706 eval.end(CGF); 707 708 eval.begin(CGF); 709 CGF.EmitBlock(RHSBlock); 710 ComplexPairTy RHS = Visit(E->getFalseExpr()); 711 RHSBlock = Builder.GetInsertBlock(); 712 CGF.EmitBlock(ContBlock); 713 eval.end(CGF); 714 715 // Create a PHI node for the real part. 716 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.r"); 717 RealPN->addIncoming(LHS.first, LHSBlock); 718 RealPN->addIncoming(RHS.first, RHSBlock); 719 720 // Create a PHI node for the imaginary part. 721 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), 2, "cond.i"); 722 ImagPN->addIncoming(LHS.second, LHSBlock); 723 ImagPN->addIncoming(RHS.second, RHSBlock); 724 725 return ComplexPairTy(RealPN, ImagPN); 726} 727 728ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 729 return Visit(E->getChosenSubExpr(CGF.getContext())); 730} 731 732ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 733 bool Ignore = TestAndClearIgnoreReal(); 734 (void)Ignore; 735 assert (Ignore == false && "init list ignored"); 736 Ignore = TestAndClearIgnoreImag(); 737 (void)Ignore; 738 assert (Ignore == false && "init list ignored"); 739 if (E->getNumInits()) 740 return Visit(E->getInit(0)); 741 742 // Empty init list intializes to null 743 QualType Ty = E->getType()->getAs<ComplexType>()->getElementType(); 744 llvm::Type* LTy = CGF.ConvertType(Ty); 745 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 746 return ComplexPairTy(zeroConstant, zeroConstant); 747} 748 749ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { 750 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr()); 751 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType()); 752 753 if (!ArgPtr) { 754 CGF.ErrorUnsupported(E, "complex va_arg expression"); 755 llvm::Type *EltTy = 756 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 757 llvm::Value *U = llvm::UndefValue::get(EltTy); 758 return ComplexPairTy(U, U); 759 } 760 761 // FIXME Volatility. 762 return EmitLoadOfComplex(ArgPtr, false); 763} 764 765//===----------------------------------------------------------------------===// 766// Entry Point into this File 767//===----------------------------------------------------------------------===// 768 769/// EmitComplexExpr - Emit the computation of the specified expression of 770/// complex type, ignoring the result. 771ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, 772 bool IgnoreImag) { 773 assert(E && E->getType()->isAnyComplexType() && 774 "Invalid complex expression to emit"); 775 776 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag) 777 .Visit(const_cast<Expr*>(E)); 778} 779 780/// EmitComplexExprIntoAddr - Emit the computation of the specified expression 781/// of complex type, storing into the specified Value*. 782void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E, 783 llvm::Value *DestAddr, 784 bool DestIsVolatile) { 785 assert(E && E->getType()->isAnyComplexType() && 786 "Invalid complex expression to emit"); 787 ComplexExprEmitter Emitter(*this); 788 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 789 Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile); 790} 791 792/// StoreComplexToAddr - Store a complex number into the specified address. 793void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V, 794 llvm::Value *DestAddr, 795 bool DestIsVolatile) { 796 ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile); 797} 798 799/// LoadComplexFromAddr - Load a complex number from the specified address. 800ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr, 801 bool SrcIsVolatile) { 802 return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile); 803} 804 805LValue CodeGenFunction::EmitComplexAssignmentLValue(const BinaryOperator *E) { 806 assert(E->getOpcode() == BO_Assign); 807 ComplexPairTy Val; // ignored 808 return ComplexExprEmitter(*this).EmitBinAssignLValue(E, Val); 809} 810 811LValue CodeGenFunction:: 812EmitComplexCompoundAssignmentLValue(const CompoundAssignOperator *E) { 813 ComplexPairTy(ComplexExprEmitter::*Op)(const ComplexExprEmitter::BinOpInfo &); 814 switch (E->getOpcode()) { 815 case BO_MulAssign: Op = &ComplexExprEmitter::EmitBinMul; break; 816 case BO_DivAssign: Op = &ComplexExprEmitter::EmitBinDiv; break; 817 case BO_SubAssign: Op = &ComplexExprEmitter::EmitBinSub; break; 818 case BO_AddAssign: Op = &ComplexExprEmitter::EmitBinAdd; break; 819 820 default: 821 llvm_unreachable("unexpected complex compound assignment"); 822 Op = 0; 823 } 824 825 ComplexPairTy Val; // ignored 826 return ComplexExprEmitter(*this).EmitCompoundAssignLValue(E, Op, Val); 827} 828