granicus.if.org Git - clang/blob - CodeGen/CGExprScalar.cpp

   1 //===--- CGExprScalar.cpp - Emit LLVM Code for Scalar 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 scalar LLVM types as LLVM code.
  11 //
  12 //===----------------------------------------------------------------------===//
  13
  14 #include "CodeGenFunction.h"
  15 #include "CodeGenModule.h"
  16 #include "clang/AST/AST.h"
  17 #include "llvm/Constants.h"
  18 #include "llvm/Function.h"
  19 #include "llvm/GlobalVariable.h"
  20 #include "llvm/Intrinsics.h"
  21 #include "llvm/Support/Compiler.h"
  22 #include <cstdarg>
  23
  24 using namespace clang;
  25 using namespace CodeGen;
  26 using llvm::Value;
  27
  28 //===----------------------------------------------------------------------===//
  29 //                         Scalar Expression Emitter
  30 //===----------------------------------------------------------------------===//
  31
  32 struct BinOpInfo {
  33   Value *LHS;
  34   Value *RHS;
  35   QualType Ty;  // Computation Type.
  36   const BinaryOperator *E;
  37 };
  38
  39 namespace {
  40 class VISIBILITY_HIDDEN ScalarExprEmitter
  41   : public StmtVisitor<ScalarExprEmitter, Value*> {
  42   CodeGenFunction &CGF;
  43   llvm::LLVMFoldingBuilder &Builder;
  44 public:
  45
  46   ScalarExprEmitter(CodeGenFunction &cgf) : CGF(cgf), Builder(CGF.Builder) {
  47   }
  48
  49
  50   //===--------------------------------------------------------------------===//
  51   //                               Utilities
  52   //===--------------------------------------------------------------------===//
  53
  54   const llvm::Type *ConvertType(QualType T) { return CGF.ConvertType(T); }
  55   LValue EmitLValue(const Expr *E) { return CGF.EmitLValue(E); }
  56
  57   Value *EmitLoadOfLValue(LValue LV, QualType T) {
  58     return CGF.EmitLoadOfLValue(LV, T).getScalarVal();
  59   }
  60
  61   /// EmitLoadOfLValue - Given an expression with complex type that represents a
  62   /// value l-value, this method emits the address of the l-value, then loads
  63   /// and returns the result.
  64   Value *EmitLoadOfLValue(const Expr *E) {
  65     // FIXME: Volatile
  66     return EmitLoadOfLValue(EmitLValue(E), E->getType());
  67   }
  68
  69   /// EmitConversionToBool - Convert the specified expression value to a
  70   /// boolean (i1) truth value.  This is equivalent to "Val != 0".
  71   Value *EmitConversionToBool(Value *Src, QualType DstTy);
  72
  73   /// EmitScalarConversion - Emit a conversion from the specified type to the
  74   /// specified destination type, both of which are LLVM scalar types.
  75   Value *EmitScalarConversion(Value *Src, QualType SrcTy, QualType DstTy);
  76
  77   /// EmitComplexToScalarConversion - Emit a conversion from the specified
  78   /// complex type to the specified destination type, where the destination
  79   /// type is an LLVM scalar type.
  80   Value *EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,
  81                                        QualType SrcTy, QualType DstTy);
  82
  83   //===--------------------------------------------------------------------===//
  84   //                            Visitor Methods
  85   //===--------------------------------------------------------------------===//
  86
  87   Value *VisitStmt(Stmt *S) {
  88     S->dump(CGF.getContext().getSourceManager());
  89     assert(0 && "Stmt can't have complex result type!");
  90     return 0;
  91   }
  92   Value *VisitExpr(Expr *S);
  93   Value *VisitParenExpr(ParenExpr *PE) { return Visit(PE->getSubExpr()); }
  94
  95   // Leaves.
  96   Value *VisitIntegerLiteral(const IntegerLiteral *E) {
  97     return llvm::ConstantInt::get(E->getValue());
  98   }
  99   Value *VisitFloatingLiteral(const FloatingLiteral *E) {
 100     return llvm::ConstantFP::get(ConvertType(E->getType()), E->getValue());
 101   }
 102   Value *VisitCharacterLiteral(const CharacterLiteral *E) {
 103     return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
 104   }
 105   Value *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
 106     return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
 107   }
 108   Value *VisitTypesCompatibleExpr(const TypesCompatibleExpr *E) {
 109     return llvm::ConstantInt::get(ConvertType(E->getType()),
 110                                   CGF.getContext().typesAreCompatible(
 111                                     E->getArgType1(), E->getArgType2()));
 112   }
 113   Value *VisitSizeOfAlignOfTypeExpr(const SizeOfAlignOfTypeExpr *E) {
 114     return EmitSizeAlignOf(E->getArgumentType(), E->getType(), E->isSizeOf());
 115   }
 116
 117   // l-values.
 118   Value *VisitDeclRefExpr(DeclRefExpr *E) {
 119     if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(E->getDecl()))
 120       return llvm::ConstantInt::get(EC->getInitVal());
 121     return EmitLoadOfLValue(E);
 122   }
 123   Value *VisitArraySubscriptExpr(ArraySubscriptExpr *E);
 124   Value *VisitMemberExpr(Expr *E)           { return EmitLoadOfLValue(E); }
 125   Value *VisitOCUVectorElementExpr(Expr *E) { return EmitLoadOfLValue(E); }
 126   Value *VisitStringLiteral(Expr *E)  { return EmitLValue(E).getAddress(); }
 127   Value *VisitPreDefinedExpr(Expr *E) { return EmitLValue(E).getAddress(); }
 128
 129   Value *VisitInitListExpr(InitListExpr *E) {
 130     unsigned NumInitElements = E->getNumInits();
 131
 132     const llvm::VectorType *VType =
 133       dyn_cast<llvm::VectorType>(ConvertType(E->getType()));
 134
 135     // We have a scalar in braces. Just use the first element.
 136     if (!VType)
 137       return Visit(E->getInit(0));
 138
 139     unsigned NumVectorElements = VType->getNumElements();
 140     const llvm::Type *ElementType = VType->getElementType();
 141
 142     // Emit individual vector element stores.
 143     llvm::Value *V = llvm::UndefValue::get(VType);
 144
 145     // Emit initializers
 146     unsigned i;
 147     for (i = 0; i < NumInitElements; ++i) {
 148       Value *NewV = Visit(E->getInit(i));
 149       Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i);
 150       V = Builder.CreateInsertElement(V, NewV, Idx);
 151     }
 152
 153     // Emit remaining default initializers
 154     for (/* Do not initialize i*/; i < NumVectorElements; ++i) {
 155       Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i);
 156       llvm::Value *NewV = llvm::Constant::getNullValue(ElementType);
 157       V = Builder.CreateInsertElement(V, NewV, Idx);
 158     }
 159
 160     return V;
 161   }
 162
 163   Value *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
 164     return Visit(E->getInitializer());
 165   }
 166
 167   Value *VisitImplicitCastExpr(const ImplicitCastExpr *E);
 168   Value *VisitCastExpr(const CastExpr *E) {
 169     return EmitCastExpr(E->getSubExpr(), E->getType());
 170   }
 171   Value *EmitCastExpr(const Expr *E, QualType T);
 172
 173   Value *VisitCallExpr(const CallExpr *E) {
 174     return CGF.EmitCallExpr(E).getScalarVal();
 175   }
 176
 177   Value *VisitStmtExpr(const StmtExpr *E);
 178
 179   // Unary Operators.
 180   Value *VisitPrePostIncDec(const UnaryOperator *E, bool isInc, bool isPre);
 181   Value *VisitUnaryPostDec(const UnaryOperator *E) {
 182     return VisitPrePostIncDec(E, false, false);
 183   }
 184   Value *VisitUnaryPostInc(const UnaryOperator *E) {
 185     return VisitPrePostIncDec(E, true, false);
 186   }
 187   Value *VisitUnaryPreDec(const UnaryOperator *E) {
 188     return VisitPrePostIncDec(E, false, true);
 189   }
 190   Value *VisitUnaryPreInc(const UnaryOperator *E) {
 191     return VisitPrePostIncDec(E, true, true);
 192   }
 193   Value *VisitUnaryAddrOf(const UnaryOperator *E) {
 194     return EmitLValue(E->getSubExpr()).getAddress();
 195   }
 196   Value *VisitUnaryDeref(const Expr *E) { return EmitLoadOfLValue(E); }
 197   Value *VisitUnaryPlus(const UnaryOperator *E) {
 198     return Visit(E->getSubExpr());
 199   }
 200   Value *VisitUnaryMinus    (const UnaryOperator *E);
 201   Value *VisitUnaryNot      (const UnaryOperator *E);
 202   Value *VisitUnaryLNot     (const UnaryOperator *E);
 203   Value *VisitUnarySizeOf   (const UnaryOperator *E) {
 204     return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), true);
 205   }
 206   Value *VisitUnaryAlignOf  (const UnaryOperator *E) {
 207     return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), false);
 208   }
 209   Value *EmitSizeAlignOf(QualType TypeToSize, QualType RetType,
 210                                bool isSizeOf);
 211   Value *VisitUnaryReal     (const UnaryOperator *E);
 212   Value *VisitUnaryImag     (const UnaryOperator *E);
 213   Value *VisitUnaryExtension(const UnaryOperator *E) {
 214     return Visit(E->getSubExpr());
 215   }
 216   Value *VisitUnaryOffsetOf(const UnaryOperator *E);
 217
 218   // Binary Operators.
 219   Value *EmitMul(const BinOpInfo &Ops) {
 220     return Builder.CreateMul(Ops.LHS, Ops.RHS, "mul");
 221   }
 222   Value *EmitDiv(const BinOpInfo &Ops);
 223   Value *EmitRem(const BinOpInfo &Ops);
 224   Value *EmitAdd(const BinOpInfo &Ops);
 225   Value *EmitSub(const BinOpInfo &Ops);
 226   Value *EmitShl(const BinOpInfo &Ops);
 227   Value *EmitShr(const BinOpInfo &Ops);
 228   Value *EmitAnd(const BinOpInfo &Ops) {
 229     return Builder.CreateAnd(Ops.LHS, Ops.RHS, "and");
 230   }
 231   Value *EmitXor(const BinOpInfo &Ops) {
 232     return Builder.CreateXor(Ops.LHS, Ops.RHS, "xor");
 233   }
 234   Value *EmitOr (const BinOpInfo &Ops) {
 235     return Builder.CreateOr(Ops.LHS, Ops.RHS, "or");
 236   }
 237
 238   BinOpInfo EmitBinOps(const BinaryOperator *E);
 239   Value *EmitCompoundAssign(const CompoundAssignOperator *E,
 240                             Value *(ScalarExprEmitter::*F)(const BinOpInfo &));
 241
 242   // Binary operators and binary compound assignment operators.
 243 #define HANDLEBINOP(OP) \
 244   Value *VisitBin ## OP(const BinaryOperator *E) {                         \
 245     return Emit ## OP(EmitBinOps(E));                                      \
 246   }                                                                        \
 247   Value *VisitBin ## OP ## Assign(const CompoundAssignOperator *E) {       \
 248     return EmitCompoundAssign(E, &ScalarExprEmitter::Emit ## OP);          \
 249   }
 250   HANDLEBINOP(Mul);
 251   HANDLEBINOP(Div);
 252   HANDLEBINOP(Rem);
 253   HANDLEBINOP(Add);
 254   //         (Sub) - Sub is handled specially below for ptr-ptr subtract.
 255   HANDLEBINOP(Shl);
 256   HANDLEBINOP(Shr);
 257   HANDLEBINOP(And);
 258   HANDLEBINOP(Xor);
 259   HANDLEBINOP(Or);
 260 #undef HANDLEBINOP
 261   Value *VisitBinSub(const BinaryOperator *E);
 262   Value *VisitBinSubAssign(const CompoundAssignOperator *E) {
 263     return EmitCompoundAssign(E, &ScalarExprEmitter::EmitSub);
 264   }
 265
 266   // Comparisons.
 267   Value *EmitCompare(const BinaryOperator *E, unsigned UICmpOpc,
 268                      unsigned SICmpOpc, unsigned FCmpOpc);
 269 #define VISITCOMP(CODE, UI, SI, FP) \
 270     Value *VisitBin##CODE(const BinaryOperator *E) { \
 271       return EmitCompare(E, llvm::ICmpInst::UI, llvm::ICmpInst::SI, \
 272                          llvm::FCmpInst::FP); }
 273   VISITCOMP(LT, ICMP_ULT, ICMP_SLT, FCMP_OLT);
 274   VISITCOMP(GT, ICMP_UGT, ICMP_SGT, FCMP_OGT);
 275   VISITCOMP(LE, ICMP_ULE, ICMP_SLE, FCMP_OLE);
 276   VISITCOMP(GE, ICMP_UGE, ICMP_SGE, FCMP_OGE);
 277   VISITCOMP(EQ, ICMP_EQ , ICMP_EQ , FCMP_OEQ);
 278   VISITCOMP(NE, ICMP_NE , ICMP_NE , FCMP_UNE);
 279 #undef VISITCOMP
 280
 281   Value *VisitBinAssign     (const BinaryOperator *E);
 282
 283   Value *VisitBinLAnd       (const BinaryOperator *E);
 284   Value *VisitBinLOr        (const BinaryOperator *E);
 285   Value *VisitBinComma      (const BinaryOperator *E);
 286
 287   // Other Operators.
 288   Value *VisitConditionalOperator(const ConditionalOperator *CO);
 289   Value *VisitChooseExpr(ChooseExpr *CE);
 290   Value *VisitOverloadExpr(OverloadExpr *OE);
 291   Value *VisitVAArgExpr(VAArgExpr *VE);
 292   Value *VisitObjCStringLiteral(const ObjCStringLiteral *E) {
 293     return CGF.EmitObjCStringLiteral(E);
 294   }
 295   Value *VisitObjCEncodeExpr(const ObjCEncodeExpr *E);
 296 };
 297 }  // end anonymous namespace.
 298
 299 //===----------------------------------------------------------------------===//
 300 //                                Utilities
 301 //===----------------------------------------------------------------------===//
 302
 303 /// EmitConversionToBool - Convert the specified expression value to a
 304 /// boolean (i1) truth value.  This is equivalent to "Val != 0".
 305 Value *ScalarExprEmitter::EmitConversionToBool(Value *Src, QualType SrcType) {
 306   assert(SrcType->isCanonical() && "EmitScalarConversion strips typedefs");
 307
 308   if (SrcType->isRealFloatingType()) {
 309     // Compare against 0.0 for fp scalars.
 310     llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType());
 311     return Builder.CreateFCmpUNE(Src, Zero, "tobool");
 312   }
 313
 314   assert((SrcType->isIntegerType() || SrcType->isPointerType()) &&
 315          "Unknown scalar type to convert");
 316
 317   // Because of the type rules of C, we often end up computing a logical value,
 318   // then zero extending it to int, then wanting it as a logical value again.
 319   // Optimize this common case.
 320   if (llvm::ZExtInst *ZI = dyn_cast<llvm::ZExtInst>(Src)) {
 321     if (ZI->getOperand(0)->getType() == llvm::Type::Int1Ty) {
 322       Value *Result = ZI->getOperand(0);
 323       // If there aren't any more uses, zap the instruction to save space.
 324       // Note that there can be more uses, for example if this
 325       // is the result of an assignment.
 326       if (ZI->use_empty())
 327         ZI->eraseFromParent();
 328       return Result;
 329     }
 330   }
 331
 332   // Compare against an integer or pointer null.
 333   llvm::Value *Zero = llvm::Constant::getNullValue(Src->getType());
 334   return Builder.CreateICmpNE(Src, Zero, "tobool");
 335 }
 336
 337 /// EmitScalarConversion - Emit a conversion from the specified type to the
 338 /// specified destination type, both of which are LLVM scalar types.
 339 Value *ScalarExprEmitter::EmitScalarConversion(Value *Src, QualType SrcType,
 340                                                QualType DstType) {
 341   SrcType = SrcType.getCanonicalType();
 342   DstType = DstType.getCanonicalType();
 343   if (SrcType == DstType) return Src;
 344
 345   if (DstType->isVoidType()) return 0;
 346
 347   // Handle conversions to bool first, they are special: comparisons against 0.
 348   if (DstType->isBooleanType())
 349     return EmitConversionToBool(Src, SrcType);
 350
 351   const llvm::Type *DstTy = ConvertType(DstType);
 352
 353   // Ignore conversions like int -> uint.
 354   if (Src->getType() == DstTy)
 355     return Src;
 356
 357   // Handle pointer conversions next: pointers can only be converted to/from
 358   // other pointers and integers.
 359   if (isa<PointerType>(DstType)) {
 360     // The source value may be an integer, or a pointer.
 361     if (isa<llvm::PointerType>(Src->getType()))
 362       return Builder.CreateBitCast(Src, DstTy, "conv");
 363     assert(SrcType->isIntegerType() && "Not ptr->ptr or int->ptr conversion?");
 364     return Builder.CreateIntToPtr(Src, DstTy, "conv");
 365   }
 366
 367   if (isa<PointerType>(SrcType)) {
 368     // Must be an ptr to int cast.
 369     assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?");
 370     return Builder.CreatePtrToInt(Src, DstTy, "conv");
 371   }
 372
 373   // A scalar source can be splatted to an OCU vector of the same element type
 374   if (DstType->isOCUVectorType() && !isa<VectorType>(SrcType) &&
 375       cast<llvm::VectorType>(DstTy)->getElementType() == Src->getType())
 376     return CGF.EmitVector(&Src, DstType->getAsVectorType()->getNumElements(),
 377                           true);
 378
 379   // Allow bitcast from vector to integer/fp of the same size.
 380   if (isa<llvm::VectorType>(Src->getType()) ||
 381       isa<llvm::VectorType>(DstTy))
 382     return Builder.CreateBitCast(Src, DstTy, "conv");
 383
 384   // Finally, we have the arithmetic types: real int/float.
 385   if (isa<llvm::IntegerType>(Src->getType())) {
 386     bool InputSigned = SrcType->isSignedIntegerType();
 387     if (isa<llvm::IntegerType>(DstTy))
 388       return Builder.CreateIntCast(Src, DstTy, InputSigned, "conv");
 389     else if (InputSigned)
 390       return Builder.CreateSIToFP(Src, DstTy, "conv");
 391     else
 392       return Builder.CreateUIToFP(Src, DstTy, "conv");
 393   }
 394
 395   assert(Src->getType()->isFloatingPoint() && "Unknown real conversion");
 396   if (isa<llvm::IntegerType>(DstTy)) {
 397     if (DstType->isSignedIntegerType())
 398       return Builder.CreateFPToSI(Src, DstTy, "conv");
 399     else
 400       return Builder.CreateFPToUI(Src, DstTy, "conv");
 401   }
 402
 403   assert(DstTy->isFloatingPoint() && "Unknown real conversion");
 404   if (DstTy->getTypeID() < Src->getType()->getTypeID())
 405     return Builder.CreateFPTrunc(Src, DstTy, "conv");
 406   else
 407     return Builder.CreateFPExt(Src, DstTy, "conv");
 408 }
 409
 410 /// EmitComplexToScalarConversion - Emit a conversion from the specified
 411 /// complex type to the specified destination type, where the destination
 412 /// type is an LLVM scalar type.
 413 Value *ScalarExprEmitter::
 414 EmitComplexToScalarConversion(CodeGenFunction::ComplexPairTy Src,
 415                               QualType SrcTy, QualType DstTy) {
 416   // Get the source element type.
 417   SrcTy = cast<ComplexType>(SrcTy.getCanonicalType())->getElementType();
 418
 419   // Handle conversions to bool first, they are special: comparisons against 0.
 420   if (DstTy->isBooleanType()) {
 421     //  Complex != 0  -> (Real != 0) | (Imag != 0)
 422     Src.first  = EmitScalarConversion(Src.first, SrcTy, DstTy);
 423     Src.second = EmitScalarConversion(Src.second, SrcTy, DstTy);
 424     return Builder.CreateOr(Src.first, Src.second, "tobool");
 425   }
 426
 427   // C99 6.3.1.7p2: "When a value of complex type is converted to a real type,
 428   // the imaginary part of the complex value is discarded and the value of the
 429   // real part is converted according to the conversion rules for the
 430   // corresponding real type.
 431   return EmitScalarConversion(Src.first, SrcTy, DstTy);
 432 }
 433
 434
 435 //===----------------------------------------------------------------------===//
 436 //                            Visitor Methods
 437 //===----------------------------------------------------------------------===//
 438
 439 Value *ScalarExprEmitter::VisitExpr(Expr *E) {
 440   CGF.WarnUnsupported(E, "scalar expression");
 441   if (E->getType()->isVoidType())
 442     return 0;
 443   return llvm::UndefValue::get(CGF.ConvertType(E->getType()));
 444 }
 445
 446 Value *ScalarExprEmitter::VisitArraySubscriptExpr(ArraySubscriptExpr *E) {
 447   // Emit subscript expressions in rvalue context's.  For most cases, this just
 448   // loads the lvalue formed by the subscript expr.  However, we have to be
 449   // careful, because the base of a vector subscript is occasionally an rvalue,
 450   // so we can't get it as an lvalue.
 451   if (!E->getBase()->getType()->isVectorType())
 452     return EmitLoadOfLValue(E);
 453
 454   // Handle the vector case.  The base must be a vector, the index must be an
 455   // integer value.
 456   Value *Base = Visit(E->getBase());
 457   Value *Idx  = Visit(E->getIdx());
 458
 459   // FIXME: Convert Idx to i32 type.
 460   return Builder.CreateExtractElement(Base, Idx, "vecext");
 461 }
 462
 463 /// VisitImplicitCastExpr - Implicit casts are the same as normal casts, but
 464 /// also handle things like function to pointer-to-function decay, and array to
 465 /// pointer decay.
 466 Value *ScalarExprEmitter::VisitImplicitCastExpr(const ImplicitCastExpr *E) {
 467   const Expr *Op = E->getSubExpr();
 468
 469   // If this is due to array->pointer conversion, emit the array expression as
 470   // an l-value.
 471   if (Op->getType()->isArrayType()) {
 472     // FIXME: For now we assume that all source arrays map to LLVM arrays.  This
 473     // will not true when we add support for VLAs.
 474     Value *V = EmitLValue(Op).getAddress();  // Bitfields can't be arrays.
 475
 476     assert(isa<llvm::PointerType>(V->getType()) &&
 477            isa<llvm::ArrayType>(cast<llvm::PointerType>(V->getType())
 478                                 ->getElementType()) &&
 479            "Doesn't support VLAs yet!");
 480     llvm::Constant *Idx0 = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
 481
 482     llvm::Value *Ops[] = {Idx0, Idx0};
 483     V = Builder.CreateGEP(V, Ops, Ops+2, "arraydecay");
 484
 485     // The resultant pointer type can be implicitly casted to other pointer
 486     // types as well, for example void*.
 487     const llvm::Type *DestPTy = ConvertType(E->getType());
 488     assert(isa<llvm::PointerType>(DestPTy) &&
 489            "Only expect implicit cast to pointer");
 490     if (V->getType() != DestPTy)
 491       V = Builder.CreateBitCast(V, DestPTy, "ptrconv");
 492     return V;
 493
 494   } else if (E->getType()->isReferenceType()) {
 495     assert(cast<ReferenceType>(E->getType().getCanonicalType())->
 496            getReferenceeType() ==
 497            Op->getType().getCanonicalType() && "Incompatible types!");
 498
 499     return EmitLValue(Op).getAddress();
 500   }
 501
 502   return EmitCastExpr(Op, E->getType());
 503 }
 504
 505
 506 // VisitCastExpr - Emit code for an explicit or implicit cast.  Implicit casts
 507 // have to handle a more broad range of conversions than explicit casts, as they
 508 // handle things like function to ptr-to-function decay etc.
 509 Value *ScalarExprEmitter::EmitCastExpr(const Expr *E, QualType DestTy) {
 510   // Handle cases where the source is an non-complex type.
 511
 512   if (!CGF.hasAggregateLLVMType(E->getType())) {
 513     Value *Src = Visit(const_cast<Expr*>(E));
 514
 515     // Use EmitScalarConversion to perform the conversion.
 516     return EmitScalarConversion(Src, E->getType(), DestTy);
 517   }
 518
 519   if (E->getType()->isComplexType()) {
 520     // Handle cases where the source is a complex type.
 521     return EmitComplexToScalarConversion(CGF.EmitComplexExpr(E), E->getType(),
 522                                          DestTy);
 523   }
 524
 525   // Okay, this is a cast from an aggregate.  It must be a cast to void.  Just
 526   // evaluate the result and return.
 527   CGF.EmitAggExpr(E, 0, false);
 528   return 0;
 529 }
 530
 531 Value *ScalarExprEmitter::VisitStmtExpr(const StmtExpr *E) {
 532   return CGF.EmitCompoundStmt(*E->getSubStmt(), true).getScalarVal();
 533 }
 534
 535
 536 //===----------------------------------------------------------------------===//
 537 //                             Unary Operators
 538 //===----------------------------------------------------------------------===//
 539
 540 Value *ScalarExprEmitter::VisitPrePostIncDec(const UnaryOperator *E,
 541                                              bool isInc, bool isPre) {
 542   LValue LV = EmitLValue(E->getSubExpr());
 543   // FIXME: Handle volatile!
 544   Value *InVal = CGF.EmitLoadOfLValue(LV, // false
 545                                      E->getSubExpr()->getType()).getScalarVal();
 546
 547   int AmountVal = isInc ? 1 : -1;
 548
 549   Value *NextVal;
 550   if (isa<llvm::PointerType>(InVal->getType())) {
 551     // FIXME: This isn't right for VLAs.
 552     NextVal = llvm::ConstantInt::get(llvm::Type::Int32Ty, AmountVal);
 553     NextVal = Builder.CreateGEP(InVal, NextVal);
 554   } else {
 555     // Add the inc/dec to the real part.
 556     if (isa<llvm::IntegerType>(InVal->getType()))
 557       NextVal = llvm::ConstantInt::get(InVal->getType(), AmountVal);
 558     else if (InVal->getType() == llvm::Type::FloatTy)
 559       // FIXME: Handle long double.
 560       NextVal =
 561         llvm::ConstantFP::get(InVal->getType(),
 562                               llvm::APFloat(static_cast<float>(AmountVal)));
 563     else {
 564       // FIXME: Handle long double.
 565       assert(InVal->getType() == llvm::Type::DoubleTy);
 566       NextVal =
 567         llvm::ConstantFP::get(InVal->getType(),
 568                               llvm::APFloat(static_cast<double>(AmountVal)));
 569     }
 570     NextVal = Builder.CreateAdd(InVal, NextVal, isInc ? "inc" : "dec");
 571   }
 572
 573   // Store the updated result through the lvalue.
 574   CGF.EmitStoreThroughLValue(RValue::get(NextVal), LV,
 575                              E->getSubExpr()->getType());
 576
 577   // If this is a postinc, return the value read from memory, otherwise use the
 578   // updated value.
 579   return isPre ? NextVal : InVal;
 580 }
 581
 582
 583 Value *ScalarExprEmitter::VisitUnaryMinus(const UnaryOperator *E) {
 584   Value *Op = Visit(E->getSubExpr());
 585   return Builder.CreateNeg(Op, "neg");
 586 }
 587
 588 Value *ScalarExprEmitter::VisitUnaryNot(const UnaryOperator *E) {
 589   Value *Op = Visit(E->getSubExpr());
 590   return Builder.CreateNot(Op, "neg");
 591 }
 592
 593 Value *ScalarExprEmitter::VisitUnaryLNot(const UnaryOperator *E) {
 594   // Compare operand to zero.
 595   Value *BoolVal = CGF.EvaluateExprAsBool(E->getSubExpr());
 596
 597   // Invert value.
 598   // TODO: Could dynamically modify easy computations here.  For example, if
 599   // the operand is an icmp ne, turn into icmp eq.
 600   BoolVal = Builder.CreateNot(BoolVal, "lnot");
 601
 602   // ZExt result to int.
 603   return Builder.CreateZExt(BoolVal, CGF.LLVMIntTy, "lnot.ext");
 604 }
 605
 606 /// EmitSizeAlignOf - Return the size or alignment of the 'TypeToSize' type as
 607 /// an integer (RetType).
 608 Value *ScalarExprEmitter::EmitSizeAlignOf(QualType TypeToSize,
 609                                           QualType RetType,bool isSizeOf){
 610   assert(RetType->isIntegerType() && "Result type must be an integer!");
 611   uint32_t ResultWidth =
 612     static_cast<uint32_t>(CGF.getContext().getTypeSize(RetType,
 613                                                        SourceLocation()));
 614
 615   // sizeof(void) and __alignof__(void) = 1 as a gcc extension.
 616   if (TypeToSize->isVoidType())
 617     return llvm::ConstantInt::get(llvm::APInt(ResultWidth, 1));
 618
 619   /// FIXME: This doesn't handle VLAs yet!
 620   std::pair<uint64_t, unsigned> Info =
 621     CGF.getContext().getTypeInfo(TypeToSize, SourceLocation());
 622
 623   uint64_t Val = isSizeOf ? Info.first : Info.second;
 624   Val /= 8;  // Return size in bytes, not bits.
 625
 626   return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
 627 }
 628
 629 Value *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) {
 630   Expr *Op = E->getSubExpr();
 631   if (Op->getType()->isComplexType())
 632     return CGF.EmitComplexExpr(Op).first;
 633   return Visit(Op);
 634 }
 635 Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) {
 636   Expr *Op = E->getSubExpr();
 637   if (Op->getType()->isComplexType())
 638     return CGF.EmitComplexExpr(Op).second;
 639
 640   // __imag on a scalar returns zero.  Emit it the subexpr to ensure side
 641   // effects are evaluated.
 642   CGF.EmitScalarExpr(Op);
 643   return llvm::Constant::getNullValue(ConvertType(E->getType()));
 644 }
 645
 646 Value *ScalarExprEmitter::VisitUnaryOffsetOf(const UnaryOperator *E)
 647 {
 648   int64_t Val = E->evaluateOffsetOf(CGF.getContext());
 649
 650   assert(E->getType()->isIntegerType() && "Result type must be an integer!");
 651
 652   uint32_t ResultWidth = static_cast<uint32_t>(
 653     CGF.getContext().getTypeSize(E->getType(), SourceLocation()));
 654   return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
 655 }
 656
 657 //===----------------------------------------------------------------------===//
 658 //                           Binary Operators
 659 //===----------------------------------------------------------------------===//
 660
 661 BinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) {
 662   BinOpInfo Result;
 663   Result.LHS = Visit(E->getLHS());
 664   Result.RHS = Visit(E->getRHS());
 665   Result.Ty  = E->getType();
 666   Result.E = E;
 667   return Result;
 668 }
 669
 670 Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E,
 671                       Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) {
 672   QualType LHSTy = E->getLHS()->getType(), RHSTy = E->getRHS()->getType();
 673
 674   BinOpInfo OpInfo;
 675
 676   // Load the LHS and RHS operands.
 677   LValue LHSLV = EmitLValue(E->getLHS());
 678   OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy);
 679
 680   // Determine the computation type.  If the RHS is complex, then this is one of
 681   // the add/sub/mul/div operators.  All of these operators can be computed in
 682   // with just their real component even though the computation domain really is
 683   // complex.
 684   QualType ComputeType = E->getComputationType();
 685
 686   // If the computation type is complex, then the RHS is complex.  Emit the RHS.
 687   if (const ComplexType *CT = ComputeType->getAsComplexType()) {
 688     ComputeType = CT->getElementType();
 689
 690     // Emit the RHS, only keeping the real component.
 691     OpInfo.RHS = CGF.EmitComplexExpr(E->getRHS()).first;
 692     RHSTy = RHSTy->getAsComplexType()->getElementType();
 693   } else {
 694     // Otherwise the RHS is a simple scalar value.
 695     OpInfo.RHS = Visit(E->getRHS());
 696   }
 697
 698   // Convert the LHS/RHS values to the computation type.
 699   OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, ComputeType);
 700
 701   // Do not merge types for -= or += where the LHS is a pointer.
 702   if (!(E->getOpcode() == BinaryOperator::SubAssign ||
 703         E->getOpcode() == BinaryOperator::AddAssign) ||
 704       !E->getLHS()->getType()->isPointerType()) {
 705     OpInfo.RHS = EmitScalarConversion(OpInfo.RHS, RHSTy, ComputeType);
 706   }
 707   OpInfo.Ty = ComputeType;
 708   OpInfo.E = E;
 709
 710   // Expand the binary operator.
 711   Value *Result = (this->*Func)(OpInfo);
 712
 713   // Truncate the result back to the LHS type.
 714   Result = EmitScalarConversion(Result, ComputeType, LHSTy);
 715
 716   // Store the result value into the LHS lvalue.
 717   CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, E->getType());
 718
 719   return Result;
 720 }
 721
 722
 723 Value *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) {
 724   if (Ops.LHS->getType()->isFPOrFPVector())
 725     return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
 726   else if (Ops.Ty->isUnsignedIntegerType())
 727     return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
 728   else
 729     return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
 730 }
 731
 732 Value *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) {
 733   // Rem in C can't be a floating point type: C99 6.5.5p2.
 734   if (Ops.Ty->isUnsignedIntegerType())
 735     return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
 736   else
 737     return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
 738 }
 739
 740
 741 Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) {
 742   if (!Ops.Ty->isPointerType())
 743     return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add");
 744
 745   // FIXME: What about a pointer to a VLA?
 746   Value *Ptr, *Idx;
 747   Expr *IdxExp;
 748   if (isa<llvm::PointerType>(Ops.LHS->getType())) {  // pointer + int
 749     Ptr = Ops.LHS;
 750     Idx = Ops.RHS;
 751     IdxExp = Ops.E->getRHS();
 752   } else {                                           // int + pointer
 753     Ptr = Ops.RHS;
 754     Idx = Ops.LHS;
 755     IdxExp = Ops.E->getLHS();
 756   }
 757
 758   unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth();
 759   if (Width < CGF.LLVMPointerWidth) {
 760     // Zero or sign extend the pointer value based on whether the index is
 761     // signed or not.
 762     const llvm::Type *IdxType = llvm::IntegerType::get(CGF.LLVMPointerWidth);
 763     if (IdxExp->getType().getCanonicalType()->isSignedIntegerType())
 764       Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext");
 765     else
 766       Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext");
 767   }
 768
 769   return Builder.CreateGEP(Ptr, Idx, "add.ptr");
 770 }
 771
 772 Value *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) {
 773   if (!isa<llvm::PointerType>(Ops.LHS->getType()))
 774     return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub");
 775
 776   // pointer - int
 777   assert(!isa<llvm::PointerType>(Ops.RHS->getType()) &&
 778          "ptr-ptr shouldn't get here");
 779   // FIXME: The pointer could point to a VLA.
 780   Value *Idx = Builder.CreateNeg(Ops.RHS, "sub.ptr.neg");
 781
 782   unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth();
 783   if (Width < CGF.LLVMPointerWidth) {
 784     // Zero or sign extend the pointer value based on whether the index is
 785     // signed or not.
 786     const llvm::Type *IdxType = llvm::IntegerType::get(CGF.LLVMPointerWidth);
 787     if (Ops.E->getRHS()->getType().getCanonicalType()->isSignedIntegerType())
 788       Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext");
 789     else
 790       Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext");
 791   }
 792
 793   return Builder.CreateGEP(Ops.LHS, Idx, "sub.ptr");
 794 }
 795
 796 Value *ScalarExprEmitter::VisitBinSub(const BinaryOperator *E) {
 797   // "X - Y" is different from "X -= Y" in one case: when Y is a pointer.  In
 798   // the compound assignment case it is invalid, so just handle it here.
 799   if (!E->getRHS()->getType()->isPointerType())
 800     return EmitSub(EmitBinOps(E));
 801
 802   // pointer - pointer
 803   Value *LHS = Visit(E->getLHS());
 804   Value *RHS = Visit(E->getRHS());
 805
 806   const QualType LHSType = E->getLHS()->getType().getCanonicalType();
 807   const QualType LHSElementType = cast<PointerType>(LHSType)->getPointeeType();
 808   uint64_t ElementSize = CGF.getContext().getTypeSize(LHSElementType,
 809                                                       SourceLocation()) / 8;
 810
 811   const llvm::Type *ResultType = ConvertType(E->getType());
 812   LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast");
 813   RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
 814   Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");
 815
 816   // HACK: LLVM doesn't have an divide instruction that 'knows' there is no
 817   // remainder.  As such, we handle common power-of-two cases here to generate
 818   // better code.
 819   if (llvm::isPowerOf2_64(ElementSize)) {
 820     Value *ShAmt =
 821     llvm::ConstantInt::get(ResultType, llvm::Log2_64(ElementSize));
 822     return Builder.CreateAShr(BytesBetween, ShAmt, "sub.ptr.shr");
 823   }
 824
 825   // Otherwise, do a full sdiv.
 826   Value *BytesPerElt = llvm::ConstantInt::get(ResultType, ElementSize);
 827   return Builder.CreateSDiv(BytesBetween, BytesPerElt, "sub.ptr.div");
 828 }
 829
 830
 831 Value *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) {
 832   // LLVM requires the LHS and RHS to be the same type: promote or truncate the
 833   // RHS to the same size as the LHS.
 834   Value *RHS = Ops.RHS;
 835   if (Ops.LHS->getType() != RHS->getType())
 836     RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
 837
 838   return Builder.CreateShl(Ops.LHS, RHS, "shl");
 839 }
 840
 841 Value *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) {
 842   // LLVM requires the LHS and RHS to be the same type: promote or truncate the
 843   // RHS to the same size as the LHS.
 844   Value *RHS = Ops.RHS;
 845   if (Ops.LHS->getType() != RHS->getType())
 846     RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
 847
 848   if (Ops.Ty->isUnsignedIntegerType())
 849     return Builder.CreateLShr(Ops.LHS, RHS, "shr");
 850   return Builder.CreateAShr(Ops.LHS, RHS, "shr");
 851 }
 852
 853 Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc,
 854                                       unsigned SICmpOpc, unsigned FCmpOpc) {
 855   Value *Result;
 856   QualType LHSTy = E->getLHS()->getType();
 857   if (!LHSTy->isComplexType()) {
 858     Value *LHS = Visit(E->getLHS());
 859     Value *RHS = Visit(E->getRHS());
 860
 861     if (LHS->getType()->isFloatingPoint()) {
 862       Result = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
 863                                   LHS, RHS, "cmp");
 864     } else if (LHSTy->isUnsignedIntegerType()) {
 865       Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
 866                                   LHS, RHS, "cmp");
 867     } else {
 868       // Signed integers and pointers.
 869       Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc,
 870                                   LHS, RHS, "cmp");
 871     }
 872   } else {
 873     // Complex Comparison: can only be an equality comparison.
 874     CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS());
 875     CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS());
 876
 877     QualType CETy =
 878       cast<ComplexType>(LHSTy.getCanonicalType())->getElementType();
 879
 880     Value *ResultR, *ResultI;
 881     if (CETy->isRealFloatingType()) {
 882       ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
 883                                    LHS.first, RHS.first, "cmp.r");
 884       ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
 885                                    LHS.second, RHS.second, "cmp.i");
 886     } else {
 887       // Complex comparisons can only be equality comparisons.  As such, signed
 888       // and unsigned opcodes are the same.
 889       ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
 890                                    LHS.first, RHS.first, "cmp.r");
 891       ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
 892                                    LHS.second, RHS.second, "cmp.i");
 893     }
 894
 895     if (E->getOpcode() == BinaryOperator::EQ) {
 896       Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
 897     } else {
 898       assert(E->getOpcode() == BinaryOperator::NE &&
 899              "Complex comparison other than == or != ?");
 900       Result = Builder.CreateOr(ResultR, ResultI, "or.ri");
 901     }
 902   }
 903
 904   // ZExt result to int.
 905   return Builder.CreateZExt(Result, CGF.LLVMIntTy, "cmp.ext");
 906 }
 907
 908 Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) {
 909   LValue LHS = EmitLValue(E->getLHS());
 910   Value *RHS = Visit(E->getRHS());
 911
 912   // Store the value into the LHS.
 913   // FIXME: Volatility!
 914   CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType());
 915
 916   // Return the RHS.
 917   return RHS;
 918 }
 919
 920 Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
 921   Value *LHSCond = CGF.EvaluateExprAsBool(E->getLHS());
 922
 923   llvm::BasicBlock *ContBlock = new llvm::BasicBlock("land_cont");
 924   llvm::BasicBlock *RHSBlock = new llvm::BasicBlock("land_rhs");
 925
 926   llvm::BasicBlock *OrigBlock = Builder.GetInsertBlock();
 927   Builder.CreateCondBr(LHSCond, RHSBlock, ContBlock);
 928
 929   CGF.EmitBlock(RHSBlock);
 930   Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
 931
 932   // Reaquire the RHS block, as there may be subblocks inserted.
 933   RHSBlock = Builder.GetInsertBlock();
 934   CGF.EmitBlock(ContBlock);
 935
 936   // Create a PHI node.  If we just evaluted the LHS condition, the result is
 937   // false.  If we evaluated both, the result is the RHS condition.
 938   llvm::PHINode *PN = Builder.CreatePHI(llvm::Type::Int1Ty, "land");
 939   PN->reserveOperandSpace(2);
 940   PN->addIncoming(llvm::ConstantInt::getFalse(), OrigBlock);
 941   PN->addIncoming(RHSCond, RHSBlock);
 942
 943   // ZExt result to int.
 944   return Builder.CreateZExt(PN, CGF.LLVMIntTy, "land.ext");
 945 }
 946
 947 Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
 948   Value *LHSCond = CGF.EvaluateExprAsBool(E->getLHS());
 949
 950   llvm::BasicBlock *ContBlock = new llvm::BasicBlock("lor_cont");
 951   llvm::BasicBlock *RHSBlock = new llvm::BasicBlock("lor_rhs");
 952
 953   llvm::BasicBlock *OrigBlock = Builder.GetInsertBlock();
 954   Builder.CreateCondBr(LHSCond, ContBlock, RHSBlock);
 955
 956   CGF.EmitBlock(RHSBlock);
 957   Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
 958
 959   // Reaquire the RHS block, as there may be subblocks inserted.
 960   RHSBlock = Builder.GetInsertBlock();
 961   CGF.EmitBlock(ContBlock);
 962
 963   // Create a PHI node.  If we just evaluted the LHS condition, the result is
 964   // true.  If we evaluated both, the result is the RHS condition.
 965   llvm::PHINode *PN = Builder.CreatePHI(llvm::Type::Int1Ty, "lor");
 966   PN->reserveOperandSpace(2);
 967   PN->addIncoming(llvm::ConstantInt::getTrue(), OrigBlock);
 968   PN->addIncoming(RHSCond, RHSBlock);
 969
 970   // ZExt result to int.
 971   return Builder.CreateZExt(PN, CGF.LLVMIntTy, "lor.ext");
 972 }
 973
 974 Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) {
 975   CGF.EmitStmt(E->getLHS());
 976   return Visit(E->getRHS());
 977 }
 978
 979 //===----------------------------------------------------------------------===//
 980 //                             Other Operators
 981 //===----------------------------------------------------------------------===//
 982
 983 Value *ScalarExprEmitter::
 984 VisitConditionalOperator(const ConditionalOperator *E) {
 985   llvm::BasicBlock *LHSBlock = new llvm::BasicBlock("cond.?");
 986   llvm::BasicBlock *RHSBlock = new llvm::BasicBlock("cond.:");
 987   llvm::BasicBlock *ContBlock = new llvm::BasicBlock("cond.cont");
 988
 989   // Evaluate the conditional, then convert it to bool.  We do this explicitly
 990   // because we need the unconverted value if this is a GNU ?: expression with
 991   // missing middle value.
 992   Value *CondVal = CGF.EmitScalarExpr(E->getCond());
 993   Value *CondBoolVal =CGF.EmitScalarConversion(CondVal, E->getCond()->getType(),
 994                                                CGF.getContext().BoolTy);
 995   Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock);
 996
 997   CGF.EmitBlock(LHSBlock);
 998
 999   // Handle the GNU extension for missing LHS.
1000   Value *LHS;
1001   if (E->getLHS())
1002     LHS = Visit(E->getLHS());
1003   else    // Perform promotions, to handle cases like "short ?: int"
1004     LHS = EmitScalarConversion(CondVal, E->getCond()->getType(), E->getType());
1005
1006   Builder.CreateBr(ContBlock);
1007   LHSBlock = Builder.GetInsertBlock();
1008
1009   CGF.EmitBlock(RHSBlock);
1010
1011   Value *RHS = Visit(E->getRHS());
1012   Builder.CreateBr(ContBlock);
1013   RHSBlock = Builder.GetInsertBlock();
1014
1015   CGF.EmitBlock(ContBlock);
1016
1017   if (!LHS) {
1018     assert(E->getType()->isVoidType() && "Non-void value should have a value");
1019     return 0;
1020   }
1021
1022   // Create a PHI node for the real part.
1023   llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond");
1024   PN->reserveOperandSpace(2);
1025   PN->addIncoming(LHS, LHSBlock);
1026   PN->addIncoming(RHS, RHSBlock);
1027   return PN;
1028 }
1029
1030 Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) {
1031   // Emit the LHS or RHS as appropriate.
1032   return
1033     Visit(E->isConditionTrue(CGF.getContext()) ? E->getLHS() : E->getRHS());
1034 }
1035
1036 Value *ScalarExprEmitter::VisitOverloadExpr(OverloadExpr *E) {
1037   return CGF.EmitCallExpr(E->getFn(), E->arg_begin(),
1038                           E->getNumArgs(CGF.getContext())).getScalarVal();
1039 }
1040
1041 Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
1042   llvm::Value *ArgValue = EmitLValue(VE->getSubExpr()).getAddress();
1043
1044   llvm::Value *V = Builder.CreateVAArg(ArgValue, ConvertType(VE->getType()));
1045   return V;
1046 }
1047
1048 Value *ScalarExprEmitter::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
1049   std::string str;
1050   llvm::SmallVector<const RecordType *, 8> EncodingRecordTypes;
1051   CGF.getContext().getObjCEncodingForType(E->getEncodedType(), str,
1052                                           EncodingRecordTypes);
1053
1054   llvm::Constant *C = llvm::ConstantArray::get(str);
1055   C = new llvm::GlobalVariable(C->getType(), true,
1056                                llvm::GlobalValue::InternalLinkage,
1057                                C, ".str", &CGF.CGM.getModule());
1058   llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
1059   llvm::Constant *Zeros[] = { Zero, Zero };
1060   C = llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2);
1061
1062   return C;
1063 }
1064
1065 //===----------------------------------------------------------------------===//
1066 //                         Entry Point into this File
1067 //===----------------------------------------------------------------------===//
1068
1069 /// EmitComplexExpr - Emit the computation of the specified expression of
1070 /// complex type, ignoring the result.
1071 Value *CodeGenFunction::EmitScalarExpr(const Expr *E) {
1072   assert(E && !hasAggregateLLVMType(E->getType()) &&
1073          "Invalid scalar expression to emit");
1074
1075   return ScalarExprEmitter(*this).Visit(const_cast<Expr*>(E));
1076 }
1077
1078 /// EmitScalarConversion - Emit a conversion from the specified type to the
1079 /// specified destination type, both of which are LLVM scalar types.
1080 Value *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy,
1081                                              QualType DstTy) {
1082   assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) &&
1083          "Invalid scalar expression to emit");
1084   return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy);
1085 }
1086
1087 /// EmitComplexToScalarConversion - Emit a conversion from the specified
1088 /// complex type to the specified destination type, where the destination
1089 /// type is an LLVM scalar type.
1090 Value *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src,
1091                                                       QualType SrcTy,
1092                                                       QualType DstTy) {
1093   assert(SrcTy->isComplexType() && !hasAggregateLLVMType(DstTy) &&
1094          "Invalid complex -> scalar conversion");
1095   return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy,
1096                                                                 DstTy);
1097 }
1098
1099 Value *CodeGenFunction::EmitShuffleVector(Value* V1, Value *V2, ...) {
1100   assert(V1->getType() == V2->getType() &&
1101          "Vector operands must be of the same type");
1102
1103   unsigned NumElements =
1104     cast<llvm::VectorType>(V1->getType())->getNumElements();
1105
1106   va_list va;
1107   va_start(va, V2);
1108
1109   llvm::SmallVector<llvm::Constant*, 16> Args;
1110
1111   for (unsigned i = 0; i < NumElements; i++) {
1112     int n = va_arg(va, int);
1113
1114     assert(n >= 0 && n < (int)NumElements * 2 &&
1115            "Vector shuffle index out of bounds!");
1116
1117     Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, n));
1118   }
1119
1120   const char *Name = va_arg(va, const char *);
1121   va_end(va);
1122
1123   llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements);
1124
1125   return Builder.CreateShuffleVector(V1, V2, Mask, Name);
1126 }
1127
1128 llvm::Value *CodeGenFunction::EmitVector(llvm::Value * const *Vals,
1129                                          unsigned NumVals, bool isSplat)
1130 {
1131   llvm::Value *Vec
1132   = llvm::UndefValue::get(llvm::VectorType::get(Vals[0]->getType(), NumVals));
1133
1134   for (unsigned i = 0, e = NumVals ; i != e; ++i) {
1135     llvm::Value *Val = isSplat ? Vals[0] : Vals[i];
1136     llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i);
1137     Vec = Builder.CreateInsertElement(Vec, Val, Idx, "tmp");
1138   }
1139
1140   return Vec;
1141 }