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   /// FIXME: This doesn't handle VLAs yet!
 611   std::pair<uint64_t, unsigned> Info =
 612     CGF.getContext().getTypeInfo(TypeToSize, SourceLocation());
 613
 614   uint64_t Val = isSizeOf ? Info.first : Info.second;
 615   Val /= 8;  // Return size in bytes, not bits.
 616
 617   assert(RetType->isIntegerType() && "Result type must be an integer!");
 618
 619   uint32_t ResultWidth = static_cast<uint32_t>(
 620     CGF.getContext().getTypeSize(RetType, SourceLocation()));
 621   return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
 622 }
 623
 624 Value *ScalarExprEmitter::VisitUnaryReal(const UnaryOperator *E) {
 625   Expr *Op = E->getSubExpr();
 626   if (Op->getType()->isComplexType())
 627     return CGF.EmitComplexExpr(Op).first;
 628   return Visit(Op);
 629 }
 630 Value *ScalarExprEmitter::VisitUnaryImag(const UnaryOperator *E) {
 631   Expr *Op = E->getSubExpr();
 632   if (Op->getType()->isComplexType())
 633     return CGF.EmitComplexExpr(Op).second;
 634
 635   // __imag on a scalar returns zero.  Emit it the subexpr to ensure side
 636   // effects are evaluated.
 637   CGF.EmitScalarExpr(Op);
 638   return llvm::Constant::getNullValue(ConvertType(E->getType()));
 639 }
 640
 641 Value *ScalarExprEmitter::VisitUnaryOffsetOf(const UnaryOperator *E)
 642 {
 643   int64_t Val = E->evaluateOffsetOf(CGF.getContext());
 644
 645   assert(E->getType()->isIntegerType() && "Result type must be an integer!");
 646
 647   uint32_t ResultWidth = static_cast<uint32_t>(
 648     CGF.getContext().getTypeSize(E->getType(), SourceLocation()));
 649   return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
 650 }
 651
 652 //===----------------------------------------------------------------------===//
 653 //                           Binary Operators
 654 //===----------------------------------------------------------------------===//
 655
 656 BinOpInfo ScalarExprEmitter::EmitBinOps(const BinaryOperator *E) {
 657   BinOpInfo Result;
 658   Result.LHS = Visit(E->getLHS());
 659   Result.RHS = Visit(E->getRHS());
 660   Result.Ty  = E->getType();
 661   Result.E = E;
 662   return Result;
 663 }
 664
 665 Value *ScalarExprEmitter::EmitCompoundAssign(const CompoundAssignOperator *E,
 666                       Value *(ScalarExprEmitter::*Func)(const BinOpInfo &)) {
 667   QualType LHSTy = E->getLHS()->getType(), RHSTy = E->getRHS()->getType();
 668
 669   BinOpInfo OpInfo;
 670
 671   // Load the LHS and RHS operands.
 672   LValue LHSLV = EmitLValue(E->getLHS());
 673   OpInfo.LHS = EmitLoadOfLValue(LHSLV, LHSTy);
 674
 675   // Determine the computation type.  If the RHS is complex, then this is one of
 676   // the add/sub/mul/div operators.  All of these operators can be computed in
 677   // with just their real component even though the computation domain really is
 678   // complex.
 679   QualType ComputeType = E->getComputationType();
 680
 681   // If the computation type is complex, then the RHS is complex.  Emit the RHS.
 682   if (const ComplexType *CT = ComputeType->getAsComplexType()) {
 683     ComputeType = CT->getElementType();
 684
 685     // Emit the RHS, only keeping the real component.
 686     OpInfo.RHS = CGF.EmitComplexExpr(E->getRHS()).first;
 687     RHSTy = RHSTy->getAsComplexType()->getElementType();
 688   } else {
 689     // Otherwise the RHS is a simple scalar value.
 690     OpInfo.RHS = Visit(E->getRHS());
 691   }
 692
 693   // Convert the LHS/RHS values to the computation type.
 694   OpInfo.LHS = EmitScalarConversion(OpInfo.LHS, LHSTy, ComputeType);
 695
 696   // Do not merge types for -= or += where the LHS is a pointer.
 697   if (!(E->getOpcode() == BinaryOperator::SubAssign ||
 698         E->getOpcode() == BinaryOperator::AddAssign) ||
 699       !E->getLHS()->getType()->isPointerType()) {
 700     OpInfo.RHS = EmitScalarConversion(OpInfo.RHS, RHSTy, ComputeType);
 701   }
 702   OpInfo.Ty = ComputeType;
 703   OpInfo.E = E;
 704
 705   // Expand the binary operator.
 706   Value *Result = (this->*Func)(OpInfo);
 707
 708   // Truncate the result back to the LHS type.
 709   Result = EmitScalarConversion(Result, ComputeType, LHSTy);
 710
 711   // Store the result value into the LHS lvalue.
 712   CGF.EmitStoreThroughLValue(RValue::get(Result), LHSLV, E->getType());
 713
 714   return Result;
 715 }
 716
 717
 718 Value *ScalarExprEmitter::EmitDiv(const BinOpInfo &Ops) {
 719   if (Ops.LHS->getType()->isFPOrFPVector())
 720     return Builder.CreateFDiv(Ops.LHS, Ops.RHS, "div");
 721   else if (Ops.Ty->isUnsignedIntegerType())
 722     return Builder.CreateUDiv(Ops.LHS, Ops.RHS, "div");
 723   else
 724     return Builder.CreateSDiv(Ops.LHS, Ops.RHS, "div");
 725 }
 726
 727 Value *ScalarExprEmitter::EmitRem(const BinOpInfo &Ops) {
 728   // Rem in C can't be a floating point type: C99 6.5.5p2.
 729   if (Ops.Ty->isUnsignedIntegerType())
 730     return Builder.CreateURem(Ops.LHS, Ops.RHS, "rem");
 731   else
 732     return Builder.CreateSRem(Ops.LHS, Ops.RHS, "rem");
 733 }
 734
 735
 736 Value *ScalarExprEmitter::EmitAdd(const BinOpInfo &Ops) {
 737   if (!Ops.Ty->isPointerType())
 738     return Builder.CreateAdd(Ops.LHS, Ops.RHS, "add");
 739
 740   // FIXME: What about a pointer to a VLA?
 741   Value *Ptr, *Idx;
 742   Expr *IdxExp;
 743   if (isa<llvm::PointerType>(Ops.LHS->getType())) {  // pointer + int
 744     Ptr = Ops.LHS;
 745     Idx = Ops.RHS;
 746     IdxExp = Ops.E->getRHS();
 747   } else {                                           // int + pointer
 748     Ptr = Ops.RHS;
 749     Idx = Ops.LHS;
 750     IdxExp = Ops.E->getLHS();
 751   }
 752
 753   unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth();
 754   if (Width < CGF.LLVMPointerWidth) {
 755     // Zero or sign extend the pointer value based on whether the index is
 756     // signed or not.
 757     const llvm::Type *IdxType = llvm::IntegerType::get(CGF.LLVMPointerWidth);
 758     if (IdxExp->getType().getCanonicalType()->isSignedIntegerType())
 759       Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext");
 760     else
 761       Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext");
 762   }
 763
 764   return Builder.CreateGEP(Ptr, Idx, "add.ptr");
 765 }
 766
 767 Value *ScalarExprEmitter::EmitSub(const BinOpInfo &Ops) {
 768   if (!isa<llvm::PointerType>(Ops.LHS->getType()))
 769     return Builder.CreateSub(Ops.LHS, Ops.RHS, "sub");
 770
 771   // pointer - int
 772   assert(!isa<llvm::PointerType>(Ops.RHS->getType()) &&
 773          "ptr-ptr shouldn't get here");
 774   // FIXME: The pointer could point to a VLA.
 775   Value *Idx = Builder.CreateNeg(Ops.RHS, "sub.ptr.neg");
 776
 777   unsigned Width = cast<llvm::IntegerType>(Idx->getType())->getBitWidth();
 778   if (Width < CGF.LLVMPointerWidth) {
 779     // Zero or sign extend the pointer value based on whether the index is
 780     // signed or not.
 781     const llvm::Type *IdxType = llvm::IntegerType::get(CGF.LLVMPointerWidth);
 782     if (Ops.E->getRHS()->getType().getCanonicalType()->isSignedIntegerType())
 783       Idx = Builder.CreateSExt(Idx, IdxType, "idx.ext");
 784     else
 785       Idx = Builder.CreateZExt(Idx, IdxType, "idx.ext");
 786   }
 787
 788   return Builder.CreateGEP(Ops.LHS, Idx, "sub.ptr");
 789 }
 790
 791 Value *ScalarExprEmitter::VisitBinSub(const BinaryOperator *E) {
 792   // "X - Y" is different from "X -= Y" in one case: when Y is a pointer.  In
 793   // the compound assignment case it is invalid, so just handle it here.
 794   if (!E->getRHS()->getType()->isPointerType())
 795     return EmitSub(EmitBinOps(E));
 796
 797   // pointer - pointer
 798   Value *LHS = Visit(E->getLHS());
 799   Value *RHS = Visit(E->getRHS());
 800
 801   const QualType LHSType = E->getLHS()->getType().getCanonicalType();
 802   const QualType LHSElementType = cast<PointerType>(LHSType)->getPointeeType();
 803   uint64_t ElementSize = CGF.getContext().getTypeSize(LHSElementType,
 804                                                       SourceLocation()) / 8;
 805
 806   const llvm::Type *ResultType = ConvertType(E->getType());
 807   LHS = Builder.CreatePtrToInt(LHS, ResultType, "sub.ptr.lhs.cast");
 808   RHS = Builder.CreatePtrToInt(RHS, ResultType, "sub.ptr.rhs.cast");
 809   Value *BytesBetween = Builder.CreateSub(LHS, RHS, "sub.ptr.sub");
 810
 811   // HACK: LLVM doesn't have an divide instruction that 'knows' there is no
 812   // remainder.  As such, we handle common power-of-two cases here to generate
 813   // better code.
 814   if (llvm::isPowerOf2_64(ElementSize)) {
 815     Value *ShAmt =
 816     llvm::ConstantInt::get(ResultType, llvm::Log2_64(ElementSize));
 817     return Builder.CreateAShr(BytesBetween, ShAmt, "sub.ptr.shr");
 818   }
 819
 820   // Otherwise, do a full sdiv.
 821   Value *BytesPerElt = llvm::ConstantInt::get(ResultType, ElementSize);
 822   return Builder.CreateSDiv(BytesBetween, BytesPerElt, "sub.ptr.div");
 823 }
 824
 825
 826 Value *ScalarExprEmitter::EmitShl(const BinOpInfo &Ops) {
 827   // LLVM requires the LHS and RHS to be the same type: promote or truncate the
 828   // RHS to the same size as the LHS.
 829   Value *RHS = Ops.RHS;
 830   if (Ops.LHS->getType() != RHS->getType())
 831     RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
 832
 833   return Builder.CreateShl(Ops.LHS, RHS, "shl");
 834 }
 835
 836 Value *ScalarExprEmitter::EmitShr(const BinOpInfo &Ops) {
 837   // LLVM requires the LHS and RHS to be the same type: promote or truncate the
 838   // RHS to the same size as the LHS.
 839   Value *RHS = Ops.RHS;
 840   if (Ops.LHS->getType() != RHS->getType())
 841     RHS = Builder.CreateIntCast(RHS, Ops.LHS->getType(), false, "sh_prom");
 842
 843   if (Ops.Ty->isUnsignedIntegerType())
 844     return Builder.CreateLShr(Ops.LHS, RHS, "shr");
 845   return Builder.CreateAShr(Ops.LHS, RHS, "shr");
 846 }
 847
 848 Value *ScalarExprEmitter::EmitCompare(const BinaryOperator *E,unsigned UICmpOpc,
 849                                       unsigned SICmpOpc, unsigned FCmpOpc) {
 850   Value *Result;
 851   QualType LHSTy = E->getLHS()->getType();
 852   if (!LHSTy->isComplexType()) {
 853     Value *LHS = Visit(E->getLHS());
 854     Value *RHS = Visit(E->getRHS());
 855
 856     if (LHS->getType()->isFloatingPoint()) {
 857       Result = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
 858                                   LHS, RHS, "cmp");
 859     } else if (LHSTy->isUnsignedIntegerType()) {
 860       Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
 861                                   LHS, RHS, "cmp");
 862     } else {
 863       // Signed integers and pointers.
 864       Result = Builder.CreateICmp((llvm::ICmpInst::Predicate)SICmpOpc,
 865                                   LHS, RHS, "cmp");
 866     }
 867   } else {
 868     // Complex Comparison: can only be an equality comparison.
 869     CodeGenFunction::ComplexPairTy LHS = CGF.EmitComplexExpr(E->getLHS());
 870     CodeGenFunction::ComplexPairTy RHS = CGF.EmitComplexExpr(E->getRHS());
 871
 872     QualType CETy =
 873       cast<ComplexType>(LHSTy.getCanonicalType())->getElementType();
 874
 875     Value *ResultR, *ResultI;
 876     if (CETy->isRealFloatingType()) {
 877       ResultR = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
 878                                    LHS.first, RHS.first, "cmp.r");
 879       ResultI = Builder.CreateFCmp((llvm::FCmpInst::Predicate)FCmpOpc,
 880                                    LHS.second, RHS.second, "cmp.i");
 881     } else {
 882       // Complex comparisons can only be equality comparisons.  As such, signed
 883       // and unsigned opcodes are the same.
 884       ResultR = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
 885                                    LHS.first, RHS.first, "cmp.r");
 886       ResultI = Builder.CreateICmp((llvm::ICmpInst::Predicate)UICmpOpc,
 887                                    LHS.second, RHS.second, "cmp.i");
 888     }
 889
 890     if (E->getOpcode() == BinaryOperator::EQ) {
 891       Result = Builder.CreateAnd(ResultR, ResultI, "and.ri");
 892     } else {
 893       assert(E->getOpcode() == BinaryOperator::NE &&
 894              "Complex comparison other than == or != ?");
 895       Result = Builder.CreateOr(ResultR, ResultI, "or.ri");
 896     }
 897   }
 898
 899   // ZExt result to int.
 900   return Builder.CreateZExt(Result, CGF.LLVMIntTy, "cmp.ext");
 901 }
 902
 903 Value *ScalarExprEmitter::VisitBinAssign(const BinaryOperator *E) {
 904   LValue LHS = EmitLValue(E->getLHS());
 905   Value *RHS = Visit(E->getRHS());
 906
 907   // Store the value into the LHS.
 908   // FIXME: Volatility!
 909   CGF.EmitStoreThroughLValue(RValue::get(RHS), LHS, E->getType());
 910
 911   // Return the RHS.
 912   return RHS;
 913 }
 914
 915 Value *ScalarExprEmitter::VisitBinLAnd(const BinaryOperator *E) {
 916   Value *LHSCond = CGF.EvaluateExprAsBool(E->getLHS());
 917
 918   llvm::BasicBlock *ContBlock = new llvm::BasicBlock("land_cont");
 919   llvm::BasicBlock *RHSBlock = new llvm::BasicBlock("land_rhs");
 920
 921   llvm::BasicBlock *OrigBlock = Builder.GetInsertBlock();
 922   Builder.CreateCondBr(LHSCond, RHSBlock, ContBlock);
 923
 924   CGF.EmitBlock(RHSBlock);
 925   Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
 926
 927   // Reaquire the RHS block, as there may be subblocks inserted.
 928   RHSBlock = Builder.GetInsertBlock();
 929   CGF.EmitBlock(ContBlock);
 930
 931   // Create a PHI node.  If we just evaluted the LHS condition, the result is
 932   // false.  If we evaluated both, the result is the RHS condition.
 933   llvm::PHINode *PN = Builder.CreatePHI(llvm::Type::Int1Ty, "land");
 934   PN->reserveOperandSpace(2);
 935   PN->addIncoming(llvm::ConstantInt::getFalse(), OrigBlock);
 936   PN->addIncoming(RHSCond, RHSBlock);
 937
 938   // ZExt result to int.
 939   return Builder.CreateZExt(PN, CGF.LLVMIntTy, "land.ext");
 940 }
 941
 942 Value *ScalarExprEmitter::VisitBinLOr(const BinaryOperator *E) {
 943   Value *LHSCond = CGF.EvaluateExprAsBool(E->getLHS());
 944
 945   llvm::BasicBlock *ContBlock = new llvm::BasicBlock("lor_cont");
 946   llvm::BasicBlock *RHSBlock = new llvm::BasicBlock("lor_rhs");
 947
 948   llvm::BasicBlock *OrigBlock = Builder.GetInsertBlock();
 949   Builder.CreateCondBr(LHSCond, ContBlock, RHSBlock);
 950
 951   CGF.EmitBlock(RHSBlock);
 952   Value *RHSCond = CGF.EvaluateExprAsBool(E->getRHS());
 953
 954   // Reaquire the RHS block, as there may be subblocks inserted.
 955   RHSBlock = Builder.GetInsertBlock();
 956   CGF.EmitBlock(ContBlock);
 957
 958   // Create a PHI node.  If we just evaluted the LHS condition, the result is
 959   // true.  If we evaluated both, the result is the RHS condition.
 960   llvm::PHINode *PN = Builder.CreatePHI(llvm::Type::Int1Ty, "lor");
 961   PN->reserveOperandSpace(2);
 962   PN->addIncoming(llvm::ConstantInt::getTrue(), OrigBlock);
 963   PN->addIncoming(RHSCond, RHSBlock);
 964
 965   // ZExt result to int.
 966   return Builder.CreateZExt(PN, CGF.LLVMIntTy, "lor.ext");
 967 }
 968
 969 Value *ScalarExprEmitter::VisitBinComma(const BinaryOperator *E) {
 970   CGF.EmitStmt(E->getLHS());
 971   return Visit(E->getRHS());
 972 }
 973
 974 //===----------------------------------------------------------------------===//
 975 //                             Other Operators
 976 //===----------------------------------------------------------------------===//
 977
 978 Value *ScalarExprEmitter::
 979 VisitConditionalOperator(const ConditionalOperator *E) {
 980   llvm::BasicBlock *LHSBlock = new llvm::BasicBlock("cond.?");
 981   llvm::BasicBlock *RHSBlock = new llvm::BasicBlock("cond.:");
 982   llvm::BasicBlock *ContBlock = new llvm::BasicBlock("cond.cont");
 983
 984   // Evaluate the conditional, then convert it to bool.  We do this explicitly
 985   // because we need the unconverted value if this is a GNU ?: expression with
 986   // missing middle value.
 987   Value *CondVal = CGF.EmitScalarExpr(E->getCond());
 988   Value *CondBoolVal =CGF.EmitScalarConversion(CondVal, E->getCond()->getType(),
 989                                                CGF.getContext().BoolTy);
 990   Builder.CreateCondBr(CondBoolVal, LHSBlock, RHSBlock);
 991
 992   CGF.EmitBlock(LHSBlock);
 993
 994   // Handle the GNU extension for missing LHS.
 995   Value *LHS;
 996   if (E->getLHS())
 997     LHS = Visit(E->getLHS());
 998   else    // Perform promotions, to handle cases like "short ?: int"
 999     LHS = EmitScalarConversion(CondVal, E->getCond()->getType(), E->getType());
1000
1001   Builder.CreateBr(ContBlock);
1002   LHSBlock = Builder.GetInsertBlock();
1003
1004   CGF.EmitBlock(RHSBlock);
1005
1006   Value *RHS = Visit(E->getRHS());
1007   Builder.CreateBr(ContBlock);
1008   RHSBlock = Builder.GetInsertBlock();
1009
1010   CGF.EmitBlock(ContBlock);
1011
1012   if (!LHS) {
1013     assert(E->getType()->isVoidType() && "Non-void value should have a value");
1014     return 0;
1015   }
1016
1017   // Create a PHI node for the real part.
1018   llvm::PHINode *PN = Builder.CreatePHI(LHS->getType(), "cond");
1019   PN->reserveOperandSpace(2);
1020   PN->addIncoming(LHS, LHSBlock);
1021   PN->addIncoming(RHS, RHSBlock);
1022   return PN;
1023 }
1024
1025 Value *ScalarExprEmitter::VisitChooseExpr(ChooseExpr *E) {
1026   // Emit the LHS or RHS as appropriate.
1027   return
1028     Visit(E->isConditionTrue(CGF.getContext()) ? E->getLHS() : E->getRHS());
1029 }
1030
1031 Value *ScalarExprEmitter::VisitOverloadExpr(OverloadExpr *E) {
1032   return CGF.EmitCallExpr(E->getFn(), E->arg_begin(),
1033                           E->getNumArgs(CGF.getContext())).getScalarVal();
1034 }
1035
1036 Value *ScalarExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
1037   llvm::Value *ArgValue = EmitLValue(VE->getSubExpr()).getAddress();
1038
1039   llvm::Value *V = Builder.CreateVAArg(ArgValue, ConvertType(VE->getType()));
1040   return V;
1041 }
1042
1043 Value *ScalarExprEmitter::VisitObjCEncodeExpr(const ObjCEncodeExpr *E) {
1044   std::string str;
1045   llvm::SmallVector<const RecordType *, 8> EncodingRecordTypes;
1046   CGF.getContext().getObjCEncodingForType(E->getEncodedType(), str,
1047                                           EncodingRecordTypes);
1048
1049   llvm::Constant *C = llvm::ConstantArray::get(str);
1050   C = new llvm::GlobalVariable(C->getType(), true,
1051                                llvm::GlobalValue::InternalLinkage,
1052                                C, ".str", &CGF.CGM.getModule());
1053   llvm::Constant *Zero = llvm::Constant::getNullValue(llvm::Type::Int32Ty);
1054   llvm::Constant *Zeros[] = { Zero, Zero };
1055   C = llvm::ConstantExpr::getGetElementPtr(C, Zeros, 2);
1056
1057   return C;
1058 }
1059
1060 //===----------------------------------------------------------------------===//
1061 //                         Entry Point into this File
1062 //===----------------------------------------------------------------------===//
1063
1064 /// EmitComplexExpr - Emit the computation of the specified expression of
1065 /// complex type, ignoring the result.
1066 Value *CodeGenFunction::EmitScalarExpr(const Expr *E) {
1067   assert(E && !hasAggregateLLVMType(E->getType()) &&
1068          "Invalid scalar expression to emit");
1069
1070   return ScalarExprEmitter(*this).Visit(const_cast<Expr*>(E));
1071 }
1072
1073 /// EmitScalarConversion - Emit a conversion from the specified type to the
1074 /// specified destination type, both of which are LLVM scalar types.
1075 Value *CodeGenFunction::EmitScalarConversion(Value *Src, QualType SrcTy,
1076                                              QualType DstTy) {
1077   assert(!hasAggregateLLVMType(SrcTy) && !hasAggregateLLVMType(DstTy) &&
1078          "Invalid scalar expression to emit");
1079   return ScalarExprEmitter(*this).EmitScalarConversion(Src, SrcTy, DstTy);
1080 }
1081
1082 /// EmitComplexToScalarConversion - Emit a conversion from the specified
1083 /// complex type to the specified destination type, where the destination
1084 /// type is an LLVM scalar type.
1085 Value *CodeGenFunction::EmitComplexToScalarConversion(ComplexPairTy Src,
1086                                                       QualType SrcTy,
1087                                                       QualType DstTy) {
1088   assert(SrcTy->isComplexType() && !hasAggregateLLVMType(DstTy) &&
1089          "Invalid complex -> scalar conversion");
1090   return ScalarExprEmitter(*this).EmitComplexToScalarConversion(Src, SrcTy,
1091                                                                 DstTy);
1092 }
1093
1094 Value *CodeGenFunction::EmitShuffleVector(Value* V1, Value *V2, ...) {
1095   assert(V1->getType() == V2->getType() &&
1096          "Vector operands must be of the same type");
1097
1098   unsigned NumElements =
1099     cast<llvm::VectorType>(V1->getType())->getNumElements();
1100
1101   va_list va;
1102   va_start(va, V2);
1103
1104   llvm::SmallVector<llvm::Constant*, 16> Args;
1105
1106   for (unsigned i = 0; i < NumElements; i++) {
1107     int n = va_arg(va, int);
1108
1109     assert(n >= 0 && n < (int)NumElements * 2 &&
1110            "Vector shuffle index out of bounds!");
1111
1112     Args.push_back(llvm::ConstantInt::get(llvm::Type::Int32Ty, n));
1113   }
1114
1115   const char *Name = va_arg(va, const char *);
1116   va_end(va);
1117
1118   llvm::Constant *Mask = llvm::ConstantVector::get(&Args[0], NumElements);
1119
1120   return Builder.CreateShuffleVector(V1, V2, Mask, Name);
1121 }
1122
1123 llvm::Value *CodeGenFunction::EmitVector(llvm::Value * const *Vals,
1124                                          unsigned NumVals, bool isSplat)
1125 {
1126   llvm::Value *Vec
1127   = llvm::UndefValue::get(llvm::VectorType::get(Vals[0]->getType(), NumVals));
1128
1129   for (unsigned i = 0, e = NumVals ; i != e; ++i) {
1130     llvm::Value *Val = isSplat ? Vals[0] : Vals[i];
1131     llvm::Value *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty, i);
1132     Vec = Builder.CreateInsertElement(Vec, Val, Idx, "tmp");
1133   }
1134
1135   return Vec;
1136 }