CGExprComplex.cpp revision c110c545810670871f54d0e999b5384ca0d6519d
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; 36public: 37 ComplexExprEmitter(CodeGenFunction &cgf) : CGF(cgf), Builder(CGF.Builder) { 38 } 39 40 41 //===--------------------------------------------------------------------===// 42 // Utilities 43 //===--------------------------------------------------------------------===// 44 45 /// EmitLoadOfLValue - Given an expression with complex type that represents a 46 /// value l-value, this method emits the address of the l-value, then loads 47 /// and returns the result. 48 ComplexPairTy EmitLoadOfLValue(const Expr *E) { 49 LValue LV = CGF.EmitLValue(E); 50 return EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 51 } 52 53 /// EmitLoadOfComplex - Given a pointer to a complex value, emit code to load 54 /// the real and imaginary pieces. 55 ComplexPairTy EmitLoadOfComplex(llvm::Value *SrcPtr, bool isVolatile); 56 57 /// EmitStoreOfComplex - Store the specified real/imag parts into the 58 /// specified value pointer. 59 void EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *ResPtr, bool isVol); 60 61 /// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 62 ComplexPairTy EmitComplexToComplexCast(ComplexPairTy Val, QualType SrcType, 63 QualType DestType); 64 65 //===--------------------------------------------------------------------===// 66 // Visitor Methods 67 //===--------------------------------------------------------------------===// 68 69 ComplexPairTy VisitStmt(Stmt *S) { 70 S->dump(CGF.getContext().getSourceManager()); 71 assert(0 && "Stmt can't have complex result type!"); 72 return ComplexPairTy(); 73 } 74 ComplexPairTy VisitExpr(Expr *S); 75 ComplexPairTy VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr());} 76 ComplexPairTy VisitImaginaryLiteral(const ImaginaryLiteral *IL); 77 78 // l-values. 79 ComplexPairTy VisitDeclRefExpr(const Expr *E) { return EmitLoadOfLValue(E); } 80 ComplexPairTy VisitArraySubscriptExpr(Expr *E) { return EmitLoadOfLValue(E); } 81 ComplexPairTy VisitMemberExpr(const Expr *E) { return EmitLoadOfLValue(E); } 82 83 // FIXME: CompoundLiteralExpr 84 85 ComplexPairTy EmitCast(Expr *Op, QualType DestTy); 86 ComplexPairTy VisitImplicitCastExpr(ImplicitCastExpr *E) { 87 // Unlike for scalars, we don't have to worry about function->ptr demotion 88 // here. 89 return EmitCast(E->getSubExpr(), E->getType()); 90 } 91 ComplexPairTy VisitCastExpr(CastExpr *E) { 92 return EmitCast(E->getSubExpr(), E->getType()); 93 } 94 ComplexPairTy VisitCallExpr(const CallExpr *E); 95 ComplexPairTy VisitStmtExpr(const StmtExpr *E); 96 97 // Operators. 98 ComplexPairTy VisitPrePostIncDec(const UnaryOperator *E, 99 bool isInc, bool isPre); 100 ComplexPairTy VisitUnaryPostDec(const UnaryOperator *E) { 101 return VisitPrePostIncDec(E, false, false); 102 } 103 ComplexPairTy VisitUnaryPostInc(const UnaryOperator *E) { 104 return VisitPrePostIncDec(E, true, false); 105 } 106 ComplexPairTy VisitUnaryPreDec(const UnaryOperator *E) { 107 return VisitPrePostIncDec(E, false, true); 108 } 109 ComplexPairTy VisitUnaryPreInc(const UnaryOperator *E) { 110 return VisitPrePostIncDec(E, true, true); 111 } 112 ComplexPairTy VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); } 113 ComplexPairTy VisitUnaryPlus (const UnaryOperator *E) { 114 return Visit(E->getSubExpr()); 115 } 116 ComplexPairTy VisitUnaryMinus (const UnaryOperator *E); 117 ComplexPairTy VisitUnaryNot (const UnaryOperator *E); 118 // LNot,Real,Imag never return complex. 119 ComplexPairTy VisitUnaryExtension(const UnaryOperator *E) { 120 return Visit(E->getSubExpr()); 121 } 122 ComplexPairTy VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) { 123 return Visit(DAE->getExpr()); 124 } 125 ComplexPairTy VisitCXXZeroInitValueExpr(CXXZeroInitValueExpr *E) { 126 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 127 QualType Elem = E->getType()->getAsComplexType()->getElementType(); 128 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 129 return ComplexPairTy(Null, Null); 130 } 131 ComplexPairTy VisitImplicitValueInitExpr(ImplicitValueInitExpr *E) { 132 assert(E->getType()->isAnyComplexType() && "Expected complex type!"); 133 QualType Elem = E->getType()->getAsComplexType()->getElementType(); 134 llvm::Constant *Null = llvm::Constant::getNullValue(CGF.ConvertType(Elem)); 135 return ComplexPairTy(Null, Null); 136 } 137 138 struct BinOpInfo { 139 ComplexPairTy LHS; 140 ComplexPairTy RHS; 141 QualType Ty; // Computation Type. 142 }; 143 144 BinOpInfo EmitBinOps(const BinaryOperator *E); 145 ComplexPairTy EmitCompoundAssign(const CompoundAssignOperator *E, 146 ComplexPairTy (ComplexExprEmitter::*Func) 147 (const BinOpInfo &)); 148 149 ComplexPairTy EmitBinAdd(const BinOpInfo &Op); 150 ComplexPairTy EmitBinSub(const BinOpInfo &Op); 151 ComplexPairTy EmitBinMul(const BinOpInfo &Op); 152 ComplexPairTy EmitBinDiv(const BinOpInfo &Op); 153 154 ComplexPairTy VisitBinMul(const BinaryOperator *E) { 155 return EmitBinMul(EmitBinOps(E)); 156 } 157 ComplexPairTy VisitBinAdd(const BinaryOperator *E) { 158 return EmitBinAdd(EmitBinOps(E)); 159 } 160 ComplexPairTy VisitBinSub(const BinaryOperator *E) { 161 return EmitBinSub(EmitBinOps(E)); 162 } 163 ComplexPairTy VisitBinDiv(const BinaryOperator *E) { 164 return EmitBinDiv(EmitBinOps(E)); 165 } 166 167 // Compound assignments. 168 ComplexPairTy VisitBinAddAssign(const CompoundAssignOperator *E) { 169 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinAdd); 170 } 171 ComplexPairTy VisitBinSubAssign(const CompoundAssignOperator *E) { 172 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinSub); 173 } 174 ComplexPairTy VisitBinMulAssign(const CompoundAssignOperator *E) { 175 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinMul); 176 } 177 ComplexPairTy VisitBinDivAssign(const CompoundAssignOperator *E) { 178 return EmitCompoundAssign(E, &ComplexExprEmitter::EmitBinDiv); 179 } 180 181 // GCC rejects rem/and/or/xor for integer complex. 182 // Logical and/or always return int, never complex. 183 184 // No comparisons produce a complex result. 185 ComplexPairTy VisitBinAssign (const BinaryOperator *E); 186 ComplexPairTy VisitBinComma (const BinaryOperator *E); 187 188 189 ComplexPairTy VisitConditionalOperator(const ConditionalOperator *CO); 190 ComplexPairTy VisitChooseExpr(ChooseExpr *CE); 191 192 ComplexPairTy VisitInitListExpr(InitListExpr *E); 193 194 ComplexPairTy VisitVAArgExpr(VAArgExpr *E); 195}; 196} // end anonymous namespace. 197 198//===----------------------------------------------------------------------===// 199// Utilities 200//===----------------------------------------------------------------------===// 201 202/// EmitLoadOfComplex - Given an RValue reference for a complex, emit code to 203/// load the real and imaginary pieces, returning them as Real/Imag. 204ComplexPairTy ComplexExprEmitter::EmitLoadOfComplex(llvm::Value *SrcPtr, 205 bool isVolatile) { 206 llvm::SmallString<64> Name(SrcPtr->getNameStart(), 207 SrcPtr->getNameStart()+SrcPtr->getNameLen()); 208 209 Name += ".realp"; 210 llvm::Value *RealPtr = Builder.CreateStructGEP(SrcPtr, 0, Name.c_str()); 211 212 Name.pop_back(); // .realp -> .real 213 llvm::Value *Real = Builder.CreateLoad(RealPtr, isVolatile, Name.c_str()); 214 215 Name.resize(Name.size()-4); // .real -> .imagp 216 Name += "imagp"; 217 218 llvm::Value *ImagPtr = Builder.CreateStructGEP(SrcPtr, 1, Name.c_str()); 219 220 Name.pop_back(); // .imagp -> .imag 221 llvm::Value *Imag = Builder.CreateLoad(ImagPtr, isVolatile, Name.c_str()); 222 return ComplexPairTy(Real, Imag); 223} 224 225/// EmitStoreOfComplex - Store the specified real/imag parts into the 226/// specified value pointer. 227void ComplexExprEmitter::EmitStoreOfComplex(ComplexPairTy Val, llvm::Value *Ptr, 228 bool isVolatile) { 229 llvm::Value *RealPtr = Builder.CreateStructGEP(Ptr, 0, "real"); 230 llvm::Value *ImagPtr = Builder.CreateStructGEP(Ptr, 1, "imag"); 231 232 Builder.CreateStore(Val.first, RealPtr, isVolatile); 233 Builder.CreateStore(Val.second, ImagPtr, isVolatile); 234} 235 236 237 238//===----------------------------------------------------------------------===// 239// Visitor Methods 240//===----------------------------------------------------------------------===// 241 242ComplexPairTy ComplexExprEmitter::VisitExpr(Expr *E) { 243 CGF.ErrorUnsupported(E, "complex expression"); 244 const llvm::Type *EltTy = 245 CGF.ConvertType(E->getType()->getAsComplexType()->getElementType()); 246 llvm::Value *U = llvm::UndefValue::get(EltTy); 247 return ComplexPairTy(U, U); 248} 249 250ComplexPairTy ComplexExprEmitter:: 251VisitImaginaryLiteral(const ImaginaryLiteral *IL) { 252 llvm::Value *Imag = CGF.EmitScalarExpr(IL->getSubExpr()); 253 return ComplexPairTy(llvm::Constant::getNullValue(Imag->getType()), Imag); 254} 255 256 257ComplexPairTy ComplexExprEmitter::VisitCallExpr(const CallExpr *E) { 258 return CGF.EmitCallExpr(E).getComplexVal(); 259} 260 261ComplexPairTy ComplexExprEmitter::VisitStmtExpr(const StmtExpr *E) { 262 return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getComplexVal(); 263} 264 265/// EmitComplexToComplexCast - Emit a cast from complex value Val to DestType. 266ComplexPairTy ComplexExprEmitter::EmitComplexToComplexCast(ComplexPairTy Val, 267 QualType SrcType, 268 QualType DestType) { 269 // Get the src/dest element type. 270 SrcType = SrcType->getAsComplexType()->getElementType(); 271 DestType = DestType->getAsComplexType()->getElementType(); 272 273 // C99 6.3.1.6: When a value of complex type is converted to another 274 // complex type, both the real and imaginary parts follow the conversion 275 // rules for the corresponding real types. 276 Val.first = CGF.EmitScalarConversion(Val.first, SrcType, DestType); 277 Val.second = CGF.EmitScalarConversion(Val.second, SrcType, DestType); 278 return Val; 279} 280 281ComplexPairTy ComplexExprEmitter::EmitCast(Expr *Op, QualType DestTy) { 282 // Two cases here: cast from (complex to complex) and (scalar to complex). 283 if (Op->getType()->isAnyComplexType()) 284 return EmitComplexToComplexCast(Visit(Op), Op->getType(), DestTy); 285 286 // C99 6.3.1.7: When a value of real type is converted to a complex type, the 287 // real part of the complex result value is determined by the rules of 288 // conversion to the corresponding real type and the imaginary part of the 289 // complex result value is a positive zero or an unsigned zero. 290 llvm::Value *Elt = CGF.EmitScalarExpr(Op); 291 292 // Convert the input element to the element type of the complex. 293 DestTy = DestTy->getAsComplexType()->getElementType(); 294 Elt = CGF.EmitScalarConversion(Elt, Op->getType(), DestTy); 295 296 // Return (realval, 0). 297 return ComplexPairTy(Elt, llvm::Constant::getNullValue(Elt->getType())); 298} 299 300ComplexPairTy ComplexExprEmitter::VisitPrePostIncDec(const UnaryOperator *E, 301 bool isInc, bool isPre) { 302 LValue LV = CGF.EmitLValue(E->getSubExpr()); 303 ComplexPairTy InVal = EmitLoadOfComplex(LV.getAddress(), LV.isVolatileQualified()); 304 305 llvm::Value *NextVal; 306 if (isa<llvm::IntegerType>(InVal.first->getType())) { 307 uint64_t AmountVal = isInc ? 1 : -1; 308 NextVal = llvm::ConstantInt::get(InVal.first->getType(), AmountVal, true); 309 } else { 310 QualType ElemTy = E->getType()->getAsComplexType()->getElementType(); 311 llvm::APFloat FVal(CGF.getContext().getFloatTypeSemantics(ElemTy), 1); 312 if (!isInc) 313 FVal.changeSign(); 314 NextVal = llvm::ConstantFP::get(FVal); 315 } 316 317 // Add the inc/dec to the real part. 318 NextVal = Builder.CreateAdd(InVal.first, NextVal, isInc ? "inc" : "dec"); 319 320 ComplexPairTy IncVal(NextVal, InVal.second); 321 322 // Store the updated result through the lvalue. 323 EmitStoreOfComplex(IncVal, LV.getAddress(), LV.isVolatileQualified()); 324 325 // If this is a postinc, return the value read from memory, otherwise use the 326 // updated value. 327 return isPre ? IncVal : InVal; 328} 329 330ComplexPairTy ComplexExprEmitter::VisitUnaryMinus(const UnaryOperator *E) { 331 ComplexPairTy Op = Visit(E->getSubExpr()); 332 llvm::Value *ResR = Builder.CreateNeg(Op.first, "neg.r"); 333 llvm::Value *ResI = Builder.CreateNeg(Op.second, "neg.i"); 334 return ComplexPairTy(ResR, ResI); 335} 336 337ComplexPairTy ComplexExprEmitter::VisitUnaryNot(const UnaryOperator *E) { 338 // ~(a+ib) = a + i*-b 339 ComplexPairTy Op = Visit(E->getSubExpr()); 340 llvm::Value *ResI = Builder.CreateNeg(Op.second, "conj.i"); 341 return ComplexPairTy(Op.first, ResI); 342} 343 344ComplexPairTy ComplexExprEmitter::EmitBinAdd(const BinOpInfo &Op) { 345 llvm::Value *ResR = Builder.CreateAdd(Op.LHS.first, Op.RHS.first, "add.r"); 346 llvm::Value *ResI = Builder.CreateAdd(Op.LHS.second, Op.RHS.second, "add.i"); 347 return ComplexPairTy(ResR, ResI); 348} 349 350ComplexPairTy ComplexExprEmitter::EmitBinSub(const BinOpInfo &Op) { 351 llvm::Value *ResR = Builder.CreateSub(Op.LHS.first, Op.RHS.first, "sub.r"); 352 llvm::Value *ResI = Builder.CreateSub(Op.LHS.second, Op.RHS.second, "sub.i"); 353 return ComplexPairTy(ResR, ResI); 354} 355 356 357ComplexPairTy ComplexExprEmitter::EmitBinMul(const BinOpInfo &Op) { 358 llvm::Value *ResRl = Builder.CreateMul(Op.LHS.first, Op.RHS.first, "mul.rl"); 359 llvm::Value *ResRr = Builder.CreateMul(Op.LHS.second, Op.RHS.second,"mul.rr"); 360 llvm::Value *ResR = Builder.CreateSub(ResRl, ResRr, "mul.r"); 361 362 llvm::Value *ResIl = Builder.CreateMul(Op.LHS.second, Op.RHS.first, "mul.il"); 363 llvm::Value *ResIr = Builder.CreateMul(Op.LHS.first, Op.RHS.second, "mul.ir"); 364 llvm::Value *ResI = Builder.CreateAdd(ResIl, ResIr, "mul.i"); 365 return ComplexPairTy(ResR, ResI); 366} 367 368ComplexPairTy ComplexExprEmitter::EmitBinDiv(const BinOpInfo &Op) { 369 llvm::Value *LHSr = Op.LHS.first, *LHSi = Op.LHS.second; 370 llvm::Value *RHSr = Op.RHS.first, *RHSi = Op.RHS.second; 371 372 // (a+ib) / (c+id) = ((ac+bd)/(cc+dd)) + i((bc-ad)/(cc+dd)) 373 llvm::Value *Tmp1 = Builder.CreateMul(LHSr, RHSr, "tmp"); // a*c 374 llvm::Value *Tmp2 = Builder.CreateMul(LHSi, RHSi, "tmp"); // b*d 375 llvm::Value *Tmp3 = Builder.CreateAdd(Tmp1, Tmp2, "tmp"); // ac+bd 376 377 llvm::Value *Tmp4 = Builder.CreateMul(RHSr, RHSr, "tmp"); // c*c 378 llvm::Value *Tmp5 = Builder.CreateMul(RHSi, RHSi, "tmp"); // d*d 379 llvm::Value *Tmp6 = Builder.CreateAdd(Tmp4, Tmp5, "tmp"); // cc+dd 380 381 llvm::Value *Tmp7 = Builder.CreateMul(LHSi, RHSr, "tmp"); // b*c 382 llvm::Value *Tmp8 = Builder.CreateMul(LHSr, RHSi, "tmp"); // a*d 383 llvm::Value *Tmp9 = Builder.CreateSub(Tmp7, Tmp8, "tmp"); // bc-ad 384 385 llvm::Value *DSTr, *DSTi; 386 if (Tmp3->getType()->isFloatingPoint()) { 387 DSTr = Builder.CreateFDiv(Tmp3, Tmp6, "tmp"); 388 DSTi = Builder.CreateFDiv(Tmp9, Tmp6, "tmp"); 389 } else { 390 if (Op.Ty->getAsComplexType()->getElementType()->isUnsignedIntegerType()) { 391 DSTr = Builder.CreateUDiv(Tmp3, Tmp6, "tmp"); 392 DSTi = Builder.CreateUDiv(Tmp9, Tmp6, "tmp"); 393 } else { 394 DSTr = Builder.CreateSDiv(Tmp3, Tmp6, "tmp"); 395 DSTi = Builder.CreateSDiv(Tmp9, Tmp6, "tmp"); 396 } 397 } 398 399 return ComplexPairTy(DSTr, DSTi); 400} 401 402ComplexExprEmitter::BinOpInfo 403ComplexExprEmitter::EmitBinOps(const BinaryOperator *E) { 404 BinOpInfo Ops; 405 Ops.LHS = Visit(E->getLHS()); 406 Ops.RHS = Visit(E->getRHS()); 407 Ops.Ty = E->getType(); 408 return Ops; 409} 410 411 412// Compound assignments. 413ComplexPairTy ComplexExprEmitter:: 414EmitCompoundAssign(const CompoundAssignOperator *E, 415 ComplexPairTy (ComplexExprEmitter::*Func)(const BinOpInfo&)){ 416 QualType LHSTy = E->getLHS()->getType(), RHSTy = E->getRHS()->getType(); 417 418 // Load the LHS and RHS operands. 419 LValue LHSLV = CGF.EmitLValue(E->getLHS()); 420 421 BinOpInfo OpInfo; 422 OpInfo.Ty = E->getComputationType(); 423 424 // We know the LHS is a complex lvalue. 425 OpInfo.LHS = EmitLoadOfComplex(LHSLV.getAddress(), LHSLV.isVolatileQualified()); 426 OpInfo.LHS = EmitComplexToComplexCast(OpInfo.LHS, LHSTy, OpInfo.Ty); 427 428 // It is possible for the RHS to be complex or scalar. 429 OpInfo.RHS = EmitCast(E->getRHS(), OpInfo.Ty); 430 431 // Expand the binary operator. 432 ComplexPairTy Result = (this->*Func)(OpInfo); 433 434 // Truncate the result back to the LHS type. 435 Result = EmitComplexToComplexCast(Result, OpInfo.Ty, LHSTy); 436 437 // Store the result value into the LHS lvalue. 438 EmitStoreOfComplex(Result, LHSLV.getAddress(), LHSLV.isVolatileQualified()); 439 return Result; 440} 441 442ComplexPairTy ComplexExprEmitter::VisitBinAssign(const BinaryOperator *E) { 443 assert(CGF.getContext().getCanonicalType(E->getLHS()->getType()) == 444 CGF.getContext().getCanonicalType(E->getRHS()->getType()) && 445 "Invalid assignment"); 446 // Emit the RHS. 447 ComplexPairTy Val = Visit(E->getRHS()); 448 449 // Compute the address to store into. 450 LValue LHS = CGF.EmitLValue(E->getLHS()); 451 452 // Store into it. 453 EmitStoreOfComplex(Val, LHS.getAddress(), LHS.isVolatileQualified()); 454 return Val; 455} 456 457ComplexPairTy ComplexExprEmitter::VisitBinComma(const BinaryOperator *E) { 458 CGF.EmitStmt(E->getLHS()); 459 CGF.EnsureInsertPoint(); 460 return Visit(E->getRHS()); 461} 462 463ComplexPairTy ComplexExprEmitter:: 464VisitConditionalOperator(const ConditionalOperator *E) { 465 llvm::BasicBlock *LHSBlock = CGF.createBasicBlock("cond.true"); 466 llvm::BasicBlock *RHSBlock = CGF.createBasicBlock("cond.false"); 467 llvm::BasicBlock *ContBlock = CGF.createBasicBlock("cond.end"); 468 469 llvm::Value *Cond = CGF.EvaluateExprAsBool(E->getCond()); 470 Builder.CreateCondBr(Cond, LHSBlock, RHSBlock); 471 472 CGF.EmitBlock(LHSBlock); 473 474 // Handle the GNU extension for missing LHS. 475 assert(E->getLHS() && "Must have LHS for complex value"); 476 477 ComplexPairTy LHS = Visit(E->getLHS()); 478 LHSBlock = Builder.GetInsertBlock(); 479 CGF.EmitBranch(ContBlock); 480 481 CGF.EmitBlock(RHSBlock); 482 483 ComplexPairTy RHS = Visit(E->getRHS()); 484 RHSBlock = Builder.GetInsertBlock(); 485 CGF.EmitBranch(ContBlock); 486 487 CGF.EmitBlock(ContBlock); 488 489 // Create a PHI node for the real part. 490 llvm::PHINode *RealPN = Builder.CreatePHI(LHS.first->getType(), "cond.r"); 491 RealPN->reserveOperandSpace(2); 492 RealPN->addIncoming(LHS.first, LHSBlock); 493 RealPN->addIncoming(RHS.first, RHSBlock); 494 495 // Create a PHI node for the imaginary part. 496 llvm::PHINode *ImagPN = Builder.CreatePHI(LHS.first->getType(), "cond.i"); 497 ImagPN->reserveOperandSpace(2); 498 ImagPN->addIncoming(LHS.second, LHSBlock); 499 ImagPN->addIncoming(RHS.second, RHSBlock); 500 501 return ComplexPairTy(RealPN, ImagPN); 502} 503 504ComplexPairTy ComplexExprEmitter::VisitChooseExpr(ChooseExpr *E) { 505 return Visit(E->getChosenSubExpr(CGF.getContext())); 506} 507 508ComplexPairTy ComplexExprEmitter::VisitInitListExpr(InitListExpr *E) { 509 if (E->getNumInits()) 510 return Visit(E->getInit(0)); 511 512 // Empty init list intializes to null 513 QualType Ty = E->getType()->getAsComplexType()->getElementType(); 514 const llvm::Type* LTy = CGF.ConvertType(Ty); 515 llvm::Value* zeroConstant = llvm::Constant::getNullValue(LTy); 516 return ComplexPairTy(zeroConstant, zeroConstant); 517} 518 519ComplexPairTy ComplexExprEmitter::VisitVAArgExpr(VAArgExpr *E) { 520 llvm::Value *ArgValue = CGF.EmitVAListRef(E->getSubExpr()); 521 llvm::Value *ArgPtr = CGF.EmitVAArg(ArgValue, E->getType()); 522 523 if (!ArgPtr) { 524 CGF.ErrorUnsupported(E, "complex va_arg expression"); 525 const llvm::Type *EltTy = 526 CGF.ConvertType(E->getType()->getAsComplexType()->getElementType()); 527 llvm::Value *U = llvm::UndefValue::get(EltTy); 528 return ComplexPairTy(U, U); 529 } 530 531 // FIXME Volatility. 532 return EmitLoadOfComplex(ArgPtr, false); 533} 534 535//===----------------------------------------------------------------------===// 536// Entry Point into this File 537//===----------------------------------------------------------------------===// 538 539/// EmitComplexExpr - Emit the computation of the specified expression of 540/// complex type, ignoring the result. 541ComplexPairTy CodeGenFunction::EmitComplexExpr(const Expr *E) { 542 assert(E && E->getType()->isAnyComplexType() && 543 "Invalid complex expression to emit"); 544 545 return ComplexExprEmitter(*this).Visit(const_cast<Expr*>(E)); 546} 547 548/// EmitComplexExprIntoAddr - Emit the computation of the specified expression 549/// of complex type, storing into the specified Value*. 550void CodeGenFunction::EmitComplexExprIntoAddr(const Expr *E, 551 llvm::Value *DestAddr, 552 bool DestIsVolatile) { 553 assert(E && E->getType()->isAnyComplexType() && 554 "Invalid complex expression to emit"); 555 ComplexExprEmitter Emitter(*this); 556 ComplexPairTy Val = Emitter.Visit(const_cast<Expr*>(E)); 557 Emitter.EmitStoreOfComplex(Val, DestAddr, DestIsVolatile); 558} 559 560/// StoreComplexToAddr - Store a complex number into the specified address. 561void CodeGenFunction::StoreComplexToAddr(ComplexPairTy V, 562 llvm::Value *DestAddr, 563 bool DestIsVolatile) { 564 ComplexExprEmitter(*this).EmitStoreOfComplex(V, DestAddr, DestIsVolatile); 565} 566 567/// LoadComplexFromAddr - Load a complex number from the specified address. 568ComplexPairTy CodeGenFunction::LoadComplexFromAddr(llvm::Value *SrcAddr, 569 bool SrcIsVolatile) { 570 return ComplexExprEmitter(*this).EmitLoadOfComplex(SrcAddr, SrcIsVolatile); 571} 572