CGExprComplex.cpp revision 77d439a4d69ffe30a7607c07b3ec5113824fd53e
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; 38 // True if we should ignore the value of a=b 39 bool IgnoreRealAssign; 40 bool IgnoreImagAssign; 41public: 42 ComplexExprEmitter(CodeGenFunction &cgf, bool ir=false, bool ii=false, 43 bool irn=false, bool iin=false) 44 : CGF(cgf), Builder(CGF.Builder), IgnoreReal(ir), IgnoreImag(ii), 45 IgnoreRealAssign(irn), IgnoreImagAssign(iin) { 46 } 47 48 49 //===--------------------------------------------------------------------===// 50 // Utilities 51 //===--------------------------------------------------------------------===// 52 53 bool TestAndClearIgnoreReal() { 54 bool I = IgnoreReal; 55 IgnoreReal = false; 56 return I; 57 } 58 bool TestAndClearIgnoreImag() { 59 bool I = IgnoreImag; 60 IgnoreImag = false; 61 return I; 62 } 63 bool TestAndClearIgnoreRealAssign() { 64 bool I = IgnoreRealAssign; 65 IgnoreRealAssign = false; 66 return I; 67 } 68 bool TestAndClearIgnoreImagAssign() { 69 bool I = IgnoreImagAssign; 70 IgnoreImagAssign = false; 71 return I; 72 } 73 74 /// EmitLoadOfLValue - Given an expression with complex type that represents a 75 /// value l-value, this method emits the address of the l-value, then loads 76 /// and returns the result. 77 ComplexPairTy EmitLoadOfLValue(const Expr *E) { 78 LValue LV = CGF.EmitLValue(E); 79 if (LV.isSimple()) 80 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 81 82 if (LV.isPropertyRef()) 83 return CGF.EmitObjCPropertyGet(LV.getPropertyRefExpr()).getComplexVal(); 84 85 assert(LV.isKVCRef() && "Unknown LValue type!"); 86 return CGF.EmitObjCPropertyGet(LV.getKVCRefExpr()).getComplexVal(); 87 } 88 89 /// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load 90 /// the real and imaginary pieces. 91 ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr, bool isVolatile); 92 93 /// EmitStoreOfComplex - Store the specified real/imag parts into the 94 /// specified value pointer. 95 void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr, bool isVol); 96 97 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 98 ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType, 99 QualType DestType); 100 101 //===--------------------------------------------------------------------===// 102 // Visitor Methods 103 //===--------------------------------------------------------------------===// 104 105 ComplexPairTy VisitStmt(Stmt *S) { 106 S->dump(CGF.getContext().getSourceManager()); 107 assert(0 && "Stmt can't have complex result type!"); 108 return ComplexPairTy(); 109 } 110 ComplexPairTy VisitExpr(Expr *S); 111 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());} 112 ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL); 113 114 // l-values. 115 ComplexPairTy VisitDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); } 116 ComplexPairTy VisitObjCIvarRefExpr(ObjCIvarRefExpr *E) { 117 return EmitLoadOfLValue(E); 118 } 119 ComplexPairTy VisitObjCPropertyRefExpr(ObjCPropertyRefExpr *E) { 120 return EmitLoadOfLValue(E); 121 } 122 ComplexPairTy VisitObjCImplicitSetterGetterRefExpr( 123 ObjCImplicitSetterGetterRefExpr *E) { 124 return EmitLoadOfLValue(E); 125 } 126 ComplexPairTy VisitObjCMessageExpr(ObjCMessageExpr *E) { 127 return CGF.EmitObjCMessageExpr(E).getComplexVal(); 128 } 129 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); } 130 ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); } 131 132 // FIXME: CompoundLiteralExpr 133 134 ComplexPairTy EmitCast(CastExpr::CastKind CK, Expr *Op, QualType DestTy); 135 ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) { 136 // Unlike for scalars, we don't have to worry about function->ptr demotion 137 // here. 138 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); 139 } 140 ComplexPairTy VisitCastExpr(CastExpr *E) { 141 return EmitCast(E->getCastKind(), E->getSubExpr(), E->getType()); 142 } 143 ComplexPairTy VisitCallExpr(const CallExpr *E); 144 ComplexPairTy VisitStmtExpr(const StmtExpr *E); 145 146 // Operators. 147 ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E, 148 bool isInc, bool isPre) { 149 LValue LV = CGF.EmitLValue(E->getSubExpr()); 150 return CGF.EmitComplexPrePostIncDec(E, LV, isInc, isPre); 151 } 152 ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) { 153 return VisitPrePostIncDec(E, false, false); 154 } 155 ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) { 156 return VisitPrePostIncDec(E, true, false); 157 } 158 ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) { 159 return VisitPrePostIncDec(E, false, true); 160 } 161 ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) { 162 return VisitPrePostIncDec(E, true, true); 163 } 164 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 165 ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) { 166 TestAndClearIgnoreReal(); 167 TestAndClearIgnoreImag(); 168 TestAndClearIgnoreRealAssign(); 169 TestAndClearIgnoreImagAssign(); 170 return Visit(E->getSubExpr()); 171 } 172 ComplexPairTy VisitUnaryMinus (const UnaryOperator *E); 173 ComplexPairTy VisitUnaryNot (const UnaryOperator *E); 174 // LNot,Real,Imag never return complex. 175 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) { 176 return Visit(E->getSubExpr()); 177 } 178 ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 179 return Visit(DAE->getExpr()); 180 } 181 ComplexPairTy VisitCXXExprWithTemporaries(CXXExprWithTemporaries *E) { 182 return CGF.EmitCXXExprWithTemporaries(E).getComplexVal(); 183 } 184 ComplexPairTy VisitCXXScalarValueInitExpr(CXXScalarValueInitExpr *E) { 185 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 186 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType(); 187 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 188 return ComplexPairTy(Null, Null); 189 } 190 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 191 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 192 QualType Elem = E->getType()->getAs<ComplexType>()->getElementType(); 193 llvm::Constant *Null = 194 llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 195 return ComplexPairTy(Null, Null); 196 } 197 198 struct BinOpInfo { 199 ComplexPairTy LHS; 200 ComplexPairTy RHS; 201 QualType Ty; // Computation Type. 202 }; 203 204 BinOpInfo EmitBinOps(const BinaryOperator *E); 205 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E, 206 ComplexPairTy (ComplexExprEmitter::*Func) 207 (const BinOpInfo &)); 208 209 ComplexPairTy EmitBinAdd(const BinOpInfo &Op); 210 ComplexPairTy EmitBinSub(const BinOpInfo &Op); 211 ComplexPairTy EmitBinMul(const BinOpInfo &Op); 212 ComplexPairTy EmitBinDiv(const BinOpInfo &Op); 213 214 ComplexPairTy VisitBinMul(const BinaryOperator *E) { 215 return EmitBinMul(EmitBinOps(E)); 216 } 217 ComplexPairTy VisitBinAdd(const BinaryOperator *E) { 218 return EmitBinAdd(EmitBinOps(E)); 219 } 220 ComplexPairTy VisitBinSub(const BinaryOperator *E) { 221 return EmitBinSub(EmitBinOps(E)); 222 } 223 ComplexPairTy VisitBinDiv(const BinaryOperator *E) { 224 return EmitBinDiv(EmitBinOps(E)); 225 } 226 227 // Compound assignments. 228 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) { 229 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd); 230 } 231 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) { 232 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub); 233 } 234 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) { 235 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul); 236 } 237 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) { 238 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv); 239 } 240 241 // GCC rejects rem/and/or/xor for integer complex. 242 // Logical and/or always return int, never complex. 243 244 // No comparisons produce a complex result. 245 ComplexPairTy VisitBinAssign (const BinaryOperator *E); 246 ComplexPairTy VisitBinComma (const BinaryOperator *E); 247 248 249 ComplexPairTy VisitConditionalOperator(const ConditionalOperator *CO); 250 ComplexPairTy VisitChooseExpr(ChooseExpr *CE); 251 252 ComplexPairTy VisitInitListExpr(InitListExpr *E); 253 254 ComplexPairTy VisitVAArgExpr(VAArgExpr *E); 255}; 256} // end anonymous namespace. 257 258//===----------------------------------------------------------------------===// 259// Utilities 260//===----------------------------------------------------------------------===// 261 262/// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to 263/// load the real and imaginary pieces, returning them as Real/Imag. 264ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr, 265 bool isVolatile) { 266 llvm::Value *Real=0, *Imag=0; 267 268 if (!IgnoreReal) { 269 llvm::Value *RealP = Builder.CreateStructGEP(SrcPtr, 0, 270 SrcPtr->getName() + ".realp"); 271 Real = Builder.CreateLoad(RealP, isVolatile, SrcPtr->getName() + ".real"); 272 } 273 274 if (!IgnoreImag) { 275 llvm::Value *ImagP = Builder.CreateStructGEP(SrcPtr, 1, 276 SrcPtr->getName() + ".imagp"); 277 Imag = Builder.CreateLoad(ImagP, isVolatile, SrcPtr->getName() + ".imag"); 278 } 279 return ComplexPairTy(Real, Imag); 280} 281 282/// EmitStoreOfComplex - Store the specified real/imag parts into the 283/// specified value pointer. 284void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr, 285 bool isVolatile) { 286 llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real"); 287 llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag"); 288 289 Builder.CreateStore(Val.first, RealPtr, isVolatile); 290 Builder.CreateStore(Val.second, ImagPtr, isVolatile); 291} 292 293 294 295//===----------------------------------------------------------------------===// 296// Visitor Methods 297//===----------------------------------------------------------------------===// 298 299ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) { 300 CGF.ErrorUnsupported(E, "complex expression"); 301 const llvm::Type *EltTy = 302 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 303 llvm::Value *U = llvm::UndefValue::get(EltTy); 304 return ComplexPairTy(U, U); 305} 306 307ComplexPairTy ComplexExprEmitter:: 308VisitImaginaryLiteral(const ImaginaryLiteral *IL) { 309 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); 310 return 311 ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); 312} 313 314 315ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { 316 if (E->getCallReturnType()->isReferenceType()) 317 return EmitLoadOfLValue(E); 318 319 return CGF.EmitCallExpr(E).getComplexVal(); 320} 321 322ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) { 323 return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal(); 324} 325 326/// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 327ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val, 328 QualType SrcType, 329 QualType DestType) { 330 // Get the src/dest element type. 331 SrcType = SrcType->getAs<ComplexType>()->getElementType(); 332 DestType = DestType->getAs<ComplexType>()->getElementType(); 333 334 // C99 6.3.1.6: When a value of complex type is converted to another 335 // complex type, both the real and imaginary parts follow the conversion 336 // rules for the corresponding real types. 337 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType); 338 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType); 339 return Val; 340} 341 342ComplexPairTy ComplexExprEmitter::EmitCast(CastExpr::CastKind CK, Expr *Op, 343 QualType DestTy) { 344 // Two cases here: cast from (complex to complex) and (scalar to complex). 345 if (Op->getType()->isAnyComplexType()) 346 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy); 347 348 // FIXME: We should be looking at all of the cast kinds here, not 349 // cherry-picking the ones we have test cases for. 350 if (CK == CastExpr::CK_LValueBitCast) { 351 llvm::Value *V = CGF.EmitLValue(Op).getAddress(); 352 V = Builder.CreateBitCast(V, 353 CGF.ConvertType(CGF.getContext().getPointerType(DestTy))); 354 // FIXME: Are the qualifiers correct here? 355 return EmitLoadOfComplex(V, DestTy.isVolatileQualified()); 356 } 357 358 // C99 6.3.1.7: When a value of real type is converted to a complex type, the 359 // real part of the complex result value is determined by the rules of 360 // conversion to the corresponding real type and the imaginary part of the 361 // complex result value is a positive zero or an unsigned zero. 362 llvm::Value *Elt = CGF.EmitScalarExpr(Op); 363 364 // Convert the input element to the element type of the complex. 365 DestTy = DestTy->getAs<ComplexType>()->getElementType(); 366 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy); 367 368 // Return (realval, 0). 369 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType())); 370} 371 372ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 373 TestAndClearIgnoreReal(); 374 TestAndClearIgnoreImag(); 375 TestAndClearIgnoreRealAssign(); 376 TestAndClearIgnoreImagAssign(); 377 ComplexPairTy Op = Visit(E->getSubExpr()); 378 379 llvm::Value *ResR, *ResI; 380 if (Op.first->getType()->isFloatingPointTy()) { 381 ResR = Builder.CreateFNeg(Op.first, "neg.r"); 382 ResI = Builder.CreateFNeg(Op.second, "neg.i"); 383 } else { 384 ResR = Builder.CreateNeg(Op.first, "neg.r"); 385 ResI = Builder.CreateNeg(Op.second, "neg.i"); 386 } 387 return ComplexPairTy(ResR, ResI); 388} 389 390ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 391 TestAndClearIgnoreReal(); 392 TestAndClearIgnoreImag(); 393 TestAndClearIgnoreRealAssign(); 394 TestAndClearIgnoreImagAssign(); 395 // ~(a+ib) = a + i*-b 396 ComplexPairTy Op = Visit(E->getSubExpr()); 397 llvm::Value *ResI; 398 if (Op.second->getType()->isFloatingPointTy()) 399 ResI = Builder.CreateFNeg(Op.second, "conj.i"); 400 else 401 ResI = Builder.CreateNeg(Op.second, "conj.i"); 402 403 return ComplexPairTy(Op.first, ResI); 404} 405 406ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 407 llvm::Value *ResR, *ResI; 408 409 if (Op.LHS.first->getType()->isFloatingPointTy()) { 410 ResR = Builder.CreateFAdd(Op.LHS.first, Op.RHS.first, "add.r"); 411 ResI = Builder.CreateFAdd(Op.LHS.second, Op.RHS.second, "add.i"); 412 } else { 413 ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 414 ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 415 } 416 return ComplexPairTy(ResR, ResI); 417} 418 419ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 420 llvm::Value *ResR, *ResI; 421 if (Op.LHS.first->getType()->isFloatingPointTy()) { 422 ResR = Builder.CreateFSub(Op.LHS.first, Op.RHS.first, "sub.r"); 423 ResI = Builder.CreateFSub(Op.LHS.second, Op.RHS.second, "sub.i"); 424 } else { 425 ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 426 ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 427 } 428 return ComplexPairTy(ResR, ResI); 429} 430 431 432ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 433 using llvm::Value; 434 Value *ResR, *ResI; 435 436 if (Op.LHS.first->getType()->isFloatingPointTy()) { 437 Value *ResRl = Builder.CreateFMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 438 Value *ResRr = Builder.CreateFMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 439 ResR = Builder.CreateFSub(ResRl, ResRr, "mul.r"); 440 441 Value *ResIl = Builder.CreateFMul(Op.LHS.second, Op.RHS.first, "mul.il"); 442 Value *ResIr = Builder.CreateFMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 443 ResI = Builder.CreateFAdd(ResIl, ResIr, "mul.i"); 444 } else { 445 Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 446 Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 447 ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 448 449 Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 450 Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 451 ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 452 } 453 return ComplexPairTy(ResR, ResI); 454} 455 456ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 457 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 458 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 459 460 461 llvm::Value *DSTr, *DSTi; 462 if (Op.LHS.first->getType()->isFloatingPointTy()) { 463 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 464 llvm::Value *Tmp1 = Builder.CreateFMul(LHSr, RHSr, "tmp"); // a*c 465 llvm::Value *Tmp2 = Builder.CreateFMul(LHSi, RHSi, "tmp"); // b*d 466 llvm::Value *Tmp3 = Builder.CreateFAdd(Tmp1, Tmp2, "tmp"); // ac+bd 467 468 llvm::Value *Tmp4 = Builder.CreateFMul(RHSr, RHSr, "tmp"); // c*c 469 llvm::Value *Tmp5 = Builder.CreateFMul(RHSi, RHSi, "tmp"); // d*d 470 llvm::Value *Tmp6 = Builder.CreateFAdd(Tmp4, Tmp5, "tmp"); // cc+dd 471 472 llvm::Value *Tmp7 = Builder.CreateFMul(LHSi, RHSr, "tmp"); // b*c 473 llvm::Value *Tmp8 = Builder.CreateFMul(LHSr, RHSi, "tmp"); // a*d 474 llvm::Value *Tmp9 = Builder.CreateFSub(Tmp7, Tmp8, "tmp"); // bc-ad 475 476 DSTr = Builder.CreateFDiv(Tmp3, Tmp6, "tmp"); 477 DSTi = Builder.CreateFDiv(Tmp9, Tmp6, "tmp"); 478 } else { 479 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 480 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr, "tmp"); // a*c 481 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi, "tmp"); // b*d 482 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2, "tmp"); // ac+bd 483 484 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr, "tmp"); // c*c 485 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi, "tmp"); // d*d 486 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5, "tmp"); // cc+dd 487 488 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr, "tmp"); // b*c 489 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi, "tmp"); // a*d 490 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8, "tmp"); // bc-ad 491 492 if (Op.Ty->getAs<ComplexType>()->getElementType()->isUnsignedIntegerType()) { 493 DSTr = Builder.CreateUDiv(Tmp3, Tmp6, "tmp"); 494 DSTi = Builder.CreateUDiv(Tmp9, Tmp6, "tmp"); 495 } else { 496 DSTr = Builder.CreateSDiv(Tmp3, Tmp6, "tmp"); 497 DSTi = Builder.CreateSDiv(Tmp9, Tmp6, "tmp"); 498 } 499 } 500 501 return ComplexPairTy(DSTr, DSTi); 502} 503 504ComplexExprEmitter::BinOpInfo 505ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 506 TestAndClearIgnoreReal(); 507 TestAndClearIgnoreImag(); 508 TestAndClearIgnoreRealAssign(); 509 TestAndClearIgnoreImagAssign(); 510 BinOpInfo Ops; 511 Ops.LHS = Visit(E->getLHS()); 512 Ops.RHS = Visit(E->getRHS()); 513 Ops.Ty = E->getType(); 514 return Ops; 515} 516 517 518// Compound assignments. 519ComplexPairTy ComplexExprEmitter:: 520EmitCompoundAssign(const CompoundAssignOperator *E, 521 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 522 TestAndClearIgnoreReal(); 523 TestAndClearIgnoreImag(); 524 bool ignreal = TestAndClearIgnoreRealAssign(); 525 bool ignimag = TestAndClearIgnoreImagAssign(); 526 QualType LHSTy = E->getLHS()->getType(), RHSTy = E->getRHS()->getType(); 527 528 BinOpInfo OpInfo; 529 530 // Load the RHS and LHS operands. 531 // __block variables need to have the rhs evaluated first, plus this should 532 // improve codegen a little. It is possible for the RHS to be complex or 533 // scalar. 534 OpInfo.Ty = E->getComputationResultType(); 535 OpInfo.RHS = EmitCast(CastExpr::CK_Unknown, E->getRHS(), OpInfo.Ty); 536 537 LValue LHS = CGF.EmitLValue(E->getLHS()); 538 // We know the LHS is a complex lvalue. 539 ComplexPairTy LHSComplexPair; 540 if (LHS.isPropertyRef()) 541 LHSComplexPair = 542 CGF.EmitObjCPropertyGet(LHS.getPropertyRefExpr()).getComplexVal(); 543 else if (LHS.isKVCRef()) 544 LHSComplexPair = 545 CGF.EmitObjCPropertyGet(LHS.getKVCRefExpr()).getComplexVal(); 546 else 547 LHSComplexPair = EmitLoadOfComplex(LHS.getAddress(), 548 LHS.isVolatileQualified()); 549 550 OpInfo.LHS = EmitComplexToComplexCast(LHSComplexPair, LHSTy, OpInfo.Ty); 551 552 // Expand the binary operator. 553 ComplexPairTy Result = (this->*Func)(OpInfo); 554 555 // Truncate the result back to the LHS type. 556 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy); 557 558 // Store the result value into the LHS lvalue. 559 if (LHS.isPropertyRef()) 560 CGF.EmitObjCPropertySet(LHS.getPropertyRefExpr(), 561 RValue::getComplex(Result)); 562 else if (LHS.isKVCRef()) 563 CGF.EmitObjCPropertySet(LHS.getKVCRefExpr(), RValue::getComplex(Result)); 564 else 565 EmitStoreOfComplex(Result, LHS.getAddress(), LHS.isVolatileQualified()); 566 567 // Restore the Ignore* flags. 568 IgnoreReal = ignreal; 569 IgnoreImag = ignimag; 570 IgnoreRealAssign = ignreal; 571 IgnoreImagAssign = ignimag; 572 573 // Objective-C property assignment never reloads the value following a store. 574 if (LHS.isPropertyRef() || LHS.isKVCRef()) 575 return Result; 576 577 // Otherwise, reload the value. 578 return EmitLoadOfComplex(LHS.getAddress(), LHS.isVolatileQualified()); 579} 580 581ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 582 TestAndClearIgnoreReal(); 583 TestAndClearIgnoreImag(); 584 bool ignreal = TestAndClearIgnoreRealAssign(); 585 bool ignimag = TestAndClearIgnoreImagAssign(); 586 assert(CGF.getContext().hasSameUnqualifiedType(E->getLHS()->getType(), 587 E->getRHS()->getType()) && 588 "Invalid assignment"); 589 // Emit the RHS. 590 ComplexPairTy Val = Visit(E->getRHS()); 591 592 // Compute the address to store into. 593 LValue LHS = CGF.EmitLValue(E->getLHS()); 594 595 // Store the result value into the LHS lvalue. 596 if (LHS.isPropertyRef()) 597 CGF.EmitObjCPropertySet(LHS.getPropertyRefExpr(), RValue::getComplex(Val)); 598 else if (LHS.isKVCRef()) 599 CGF.EmitObjCPropertySet(LHS.getKVCRefExpr(), RValue::getComplex(Val)); 600 else 601 EmitStoreOfComplex(Val, LHS.getAddress(), LHS.isVolatileQualified()); 602 603 // Restore the Ignore* flags. 604 IgnoreReal = ignreal; 605 IgnoreImag = ignimag; 606 IgnoreRealAssign = ignreal; 607 IgnoreImagAssign = ignimag; 608 609 // Objective-C property assignment never reloads the value following a store. 610 if (LHS.isPropertyRef() || LHS.isKVCRef()) 611 return Val; 612 613 // Otherwise, reload the value. 614 return EmitLoadOfComplex(LHS.getAddress(), LHS.isVolatileQualified()); 615} 616 617ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 618 CGF.EmitStmt(E->getLHS()); 619 CGF.EnsureInsertPoint(); 620 return Visit(E->getRHS()); 621} 622 623ComplexPairTy ComplexExprEmitter:: 624VisitConditionalOperator(const ConditionalOperator *E) { 625 if (!E->getLHS()) { 626 CGF.ErrorUnsupported(E, "conditional operator with missing LHS"); 627 const llvm::Type *EltTy = 628 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 629 llvm::Value *U = llvm::UndefValue::get(EltTy); 630 return ComplexPairTy(U, U); 631 } 632 633 TestAndClearIgnoreReal(); 634 TestAndClearIgnoreImag(); 635 TestAndClearIgnoreRealAssign(); 636 TestAndClearIgnoreImagAssign(); 637 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 638 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 639 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 640 641 CGF.EmitBranchOnBoolExpr(E->getCond(), LHSBlock, RHSBlock); 642 643 CGF.EmitBlock(LHSBlock); 644 645 // Handle the GNU extension for missing LHS. 646 assert(E->getLHS() && "Must have LHS for complex value"); 647 648 ComplexPairTy LHS = Visit(E->getLHS()); 649 LHSBlock = Builder.GetInsertBlock(); 650 CGF.EmitBranch(ContBlock); 651 652 CGF.EmitBlock(RHSBlock); 653 654 ComplexPairTy RHS = Visit(E->getRHS()); 655 RHSBlock = Builder.GetInsertBlock(); 656 CGF.EmitBranch(ContBlock); 657 658 CGF.EmitBlock(ContBlock); 659 660 // Create a PHI node for the real part. 661 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), "cond.r"); 662 RealPN->reserveOperandSpace(2); 663 RealPN->addIncoming(LHS.first, LHSBlock); 664 RealPN->addIncoming(RHS.first, RHSBlock); 665 666 // Create a PHI node for the imaginary part. 667 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), "cond.i"); 668 ImagPN->reserveOperandSpace(2); 669 ImagPN->addIncoming(LHS.second, LHSBlock); 670 ImagPN->addIncoming(RHS.second, RHSBlock); 671 672 return ComplexPairTy(RealPN, ImagPN); 673} 674 675ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 676 return Visit(E->getChosenSubExpr(CGF.getContext())); 677} 678 679ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 680 bool Ignore = TestAndClearIgnoreReal(); 681 (void)Ignore; 682 assert (Ignore == false && "init list ignored"); 683 Ignore = TestAndClearIgnoreImag(); 684 (void)Ignore; 685 assert (Ignore == false && "init list ignored"); 686 if (E->getNumInits()) 687 return Visit(E->getInit(0)); 688 689 // Empty init list intializes to null 690 QualType Ty = E->getType()->getAs<ComplexType>()->getElementType(); 691 const llvm::Type* LTy = CGF.ConvertType(Ty); 692 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 693 return ComplexPairTy(zeroConstant, zeroConstant); 694} 695 696ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { 697 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr()); 698 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType()); 699 700 if (!ArgPtr) { 701 CGF.ErrorUnsupported(E, "complex va_arg expression"); 702 const llvm::Type *EltTy = 703 CGF.ConvertType(E->getType()->getAs<ComplexType>()->getElementType()); 704 llvm::Value *U = llvm::UndefValue::get(EltTy); 705 return ComplexPairTy(U, U); 706 } 707 708 // FIXME Volatility. 709 return EmitLoadOfComplex(ArgPtr, false); 710} 711 712//===----------------------------------------------------------------------===// 713// Entry Point into this File 714//===----------------------------------------------------------------------===// 715 716/// EmitComplexExpr - Emit the computation of the specified expression of 717/// complex type, ignoring the result. 718ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E, bool IgnoreReal, 719 bool IgnoreImag, bool IgnoreRealAssign, bool IgnoreImagAssign) { 720 assert(E && E->getType()->isAnyComplexType() && 721 "Invalid complex expression to emit"); 722 723 return ComplexExprEmitter(*this, IgnoreReal, IgnoreImag, IgnoreRealAssign, 724 IgnoreImagAssign) 725 .Visit(const_cast<Expr*>(E)); 726} 727 728/// EmitComplexExprIntoAddr - Emit the computation of the specified expression 729/// of complex type, storing into the specified Value*. 730void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E, 731 llvm::Value *DestAddr, 732 bool DestIsVolatile) { 733 assert(E && E->getType()->isAnyComplexType() && 734 "Invalid complex expression to emit"); 735 ComplexExprEmitter Emitter(*this); 736 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 737 Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile); 738} 739 740/// StoreComplexToAddr - Store a complex number into the specified address. 741void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V, 742 llvm::Value *DestAddr, 743 bool DestIsVolatile) { 744 ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile); 745} 746 747/// LoadComplexFromAddr - Load a complex number from the specified address. 748ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr, 749 bool SrcIsVolatile) { 750 return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile); 751} 752