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