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

   1 //===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===//
   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 Constant Expr nodes 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/Support/Compiler.h"
  21 using namespace clang;
  22 using namespace CodeGen;
  23
  24 namespace  {
  25 class VISIBILITY_HIDDEN ConstExprEmitter :
  26   public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
  27   CodeGenModule &CGM;
  28 public:
  29   ConstExprEmitter(CodeGenModule &cgm)
  30     : CGM(cgm) {
  31   }
  32
  33   //===--------------------------------------------------------------------===//
  34   //                            Visitor Methods
  35   //===--------------------------------------------------------------------===//
  36
  37   llvm::Constant *VisitStmt(Stmt *S) {
  38     CGM.WarnUnsupported(S, "constant expression");
  39     return 0;
  40   }
  41
  42   llvm::Constant *VisitParenExpr(ParenExpr *PE) {
  43     return Visit(PE->getSubExpr());
  44   }
  45
  46   // Leaves
  47   llvm::Constant *VisitIntegerLiteral(const IntegerLiteral *E) {
  48     return llvm::ConstantInt::get(E->getValue());
  49   }
  50   llvm::Constant *VisitFloatingLiteral(const FloatingLiteral *E) {
  51     return llvm::ConstantFP::get(ConvertType(E->getType()), E->getValue());
  52   }
  53   llvm::Constant *VisitCharacterLiteral(const CharacterLiteral *E) {
  54     return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
  55   }
  56   llvm::Constant *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
  57     return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
  58   }
  59
  60   llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
  61     return Visit(E->getInitializer());
  62   }
  63
  64   llvm::Constant *VisitCastExpr(const CastExpr* E) {
  65     llvm::Constant *C = Visit(E->getSubExpr());
  66
  67     return EmitConversion(C, E->getSubExpr()->getType(), E->getType());
  68   }
  69
  70   llvm::Constant *EmitArrayInitialization(InitListExpr *ILE,
  71                                           const llvm::ArrayType *AType) {
  72
  73     std::vector<llvm::Constant*> Elts;
  74     unsigned NumInitElements = ILE->getNumInits();
  75     const llvm::Type *ElemTy = AType->getElementType();
  76     unsigned NumElements = AType->getNumElements();
  77
  78     // Initialising an array requires us to automatically
  79     // initialise any elements that have not been initialised explicitly
  80     unsigned NumInitableElts = std::min(NumInitElements, NumElements);
  81
  82     // Copy initializer elements.
  83     unsigned i = 0;
  84     for (; i < NumInitableElts; ++i) {
  85
  86       llvm::Constant *C = Visit(ILE->getInit(i));
  87       // FIXME: Remove this when sema of initializers is finished (and the code
  88       // above).
  89       if (C == 0 && ILE->getInit(i)->getType()->isVoidType()) {
  90         if (ILE->getType()->isVoidType()) return 0;
  91         return llvm::UndefValue::get(AType);
  92       }
  93       assert (C && "Failed to create initializer expression");
  94       Elts.push_back(C);
  95     }
  96
  97     // Initialize remaining array elements.
  98     for (; i < NumElements; ++i)
  99       Elts.push_back(llvm::Constant::getNullValue(ElemTy));
 100
 101     return llvm::ConstantArray::get(AType, Elts);
 102   }
 103
 104   llvm::Constant *EmitStructInitialization(InitListExpr *ILE,
 105                                            const llvm::StructType *SType) {
 106
 107     TagDecl *TD = ILE->getType()->getAsRecordType()->getDecl();
 108     std::vector<llvm::Constant*> Elts;
 109     const CGRecordLayout *CGR = CGM.getTypes().getCGRecordLayout(TD);
 110     unsigned NumInitElements = ILE->getNumInits();
 111     unsigned NumElements = SType->getNumElements();
 112
 113     // Initialising an structure requires us to automatically
 114     // initialise any elements that have not been initialised explicitly
 115     unsigned NumInitableElts = std::min(NumInitElements, NumElements);
 116
 117     // Copy initializer elements. Skip padding fields.
 118     unsigned EltNo = 0;  // Element no in ILE
 119     unsigned FieldNo = 0; // Field no in  SType
 120     while (EltNo < NumInitableElts) {
 121
 122       // Zero initialize padding field.
 123       if (CGR->isPaddingField(FieldNo)) {
 124         const llvm::Type *FieldTy = SType->getElementType(FieldNo);
 125         Elts.push_back(llvm::Constant::getNullValue(FieldTy));
 126         FieldNo++;
 127         continue;
 128       }
 129
 130       llvm::Constant *C = Visit(ILE->getInit(EltNo));
 131       // FIXME: Remove this when sema of initializers is finished (and the code
 132       // above).
 133       if (C == 0 && ILE->getInit(EltNo)->getType()->isVoidType()) {
 134         if (ILE->getType()->isVoidType()) return 0;
 135         return llvm::UndefValue::get(SType);
 136       }
 137       assert (C && "Failed to create initializer expression");
 138       Elts.push_back(C);
 139       EltNo++;
 140       FieldNo++;
 141     }
 142
 143     // Initialize remaining structure elements.
 144     for (unsigned i = Elts.size(); i < NumElements; ++i) {
 145       const llvm::Type *FieldTy = SType->getElementType(i);
 146       Elts.push_back(llvm::Constant::getNullValue(FieldTy));
 147     }
 148
 149     return llvm::ConstantStruct::get(SType, Elts);
 150   }
 151
 152   llvm::Constant *EmitVectorInitialization(InitListExpr *ILE,
 153                                            const llvm::VectorType *VType) {
 154
 155     std::vector<llvm::Constant*> Elts;
 156     unsigned NumInitElements = ILE->getNumInits();
 157     unsigned NumElements = VType->getNumElements();
 158
 159     assert (NumInitElements == NumElements
 160             && "Unsufficient vector init elelments");
 161     // Copy initializer elements.
 162     unsigned i = 0;
 163     for (; i < NumElements; ++i) {
 164
 165       llvm::Constant *C = Visit(ILE->getInit(i));
 166       // FIXME: Remove this when sema of initializers is finished (and the code
 167       // above).
 168       if (C == 0 && ILE->getInit(i)->getType()->isVoidType()) {
 169         if (ILE->getType()->isVoidType()) return 0;
 170         return llvm::UndefValue::get(VType);
 171       }
 172       assert (C && "Failed to create initializer expression");
 173       Elts.push_back(C);
 174     }
 175
 176     return llvm::ConstantVector::get(VType, Elts);
 177   }
 178
 179   llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
 180     const llvm::CompositeType *CType =
 181       dyn_cast<llvm::CompositeType>(ConvertType(ILE->getType()));
 182
 183     if (!CType) {
 184         // We have a scalar in braces. Just use the first element.
 185         return Visit(ILE->getInit(0));
 186     }
 187
 188     if (const llvm::ArrayType *AType = dyn_cast<llvm::ArrayType>(CType))
 189       return EmitArrayInitialization(ILE, AType);
 190
 191     if (const llvm::StructType *SType = dyn_cast<llvm::StructType>(CType))
 192       return EmitStructInitialization(ILE, SType);
 193
 194     if (const llvm::VectorType *VType = dyn_cast<llvm::VectorType>(CType))
 195       return EmitVectorInitialization(ILE, VType);
 196
 197     // Make sure we have an array at this point
 198     assert(0 && "Unable to handle InitListExpr");
 199   }
 200
 201   llvm::Constant *VisitImplicitCastExpr(ImplicitCastExpr *ICExpr) {
 202     // If this is due to array->pointer conversion, emit the array expression as
 203     // an l-value.
 204     if (ICExpr->getSubExpr()->getType()->isArrayType()) {
 205       // Note that VLAs can't exist for global variables.
 206       // The only thing that can have array type like this is a
 207       // DeclRefExpr(FileVarDecl)?
 208       llvm::Constant *C = EmitLValue(ICExpr->getSubExpr());
 209       assert(isa<llvm::PointerType>(C->getType()) &&
 210              isa<llvm::ArrayType>(cast<llvm::PointerType>(C->getType())
 211                                   ->getElementType()));
 212       llvm::Constant *Idx0 = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
 213
 214       llvm::Constant *Ops[] = {Idx0, Idx0};
 215       C = llvm::ConstantExpr::getGetElementPtr(C, Ops, 2);
 216
 217       // The resultant pointer type can be implicitly cast to other pointer
 218       // types as well, for example void*.
 219       const llvm::Type *DestPTy = ConvertType(ICExpr->getType());
 220       assert(isa<llvm::PointerType>(DestPTy) &&
 221              "Only expect implicit cast to pointer");
 222       return llvm::ConstantExpr::getBitCast(C, DestPTy);
 223     }
 224
 225     llvm::Constant *C = Visit(ICExpr->getSubExpr());
 226
 227     return EmitConversion(C, ICExpr->getSubExpr()->getType(),ICExpr->getType());
 228   }
 229
 230   llvm::Constant *VisitStringLiteral(StringLiteral *E) {
 231     const char *StrData = E->getStrData();
 232     unsigned Len = E->getByteLength();
 233     assert(!E->getType()->isPointerType() && "Strings are always arrays");
 234
 235     // Otherwise this must be a string initializing an array in a static
 236     // initializer.  Don't emit it as the address of the string, emit the string
 237     // data itself as an inline array.
 238     const ConstantArrayType *CAT = E->getType()->getAsConstantArrayType();
 239     assert(CAT && "String isn't pointer or array!");
 240
 241     std::string Str(StrData, StrData + Len);
 242     // Null terminate the string before potentially truncating it.
 243     // FIXME: What about wchar_t strings?
 244     Str.push_back(0);
 245
 246     uint64_t RealLen = CAT->getSize().getZExtValue();
 247     // String or grow the initializer to the required size.
 248     if (RealLen != Str.size())
 249       Str.resize(RealLen);
 250
 251     return llvm::ConstantArray::get(Str, false);
 252   }
 253
 254   llvm::Constant *VisitDeclRefExpr(DeclRefExpr *E) {
 255     const ValueDecl *Decl = E->getDecl();
 256     if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
 257       return CGM.GetAddrOfFunctionDecl(FD, false);
 258     if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(Decl))
 259       return llvm::ConstantInt::get(EC->getInitVal());
 260     assert(0 && "Unsupported decl ref type!");
 261     return 0;
 262   }
 263
 264   llvm::Constant *VisitSizeOfAlignOfTypeExpr(const SizeOfAlignOfTypeExpr *E) {
 265     return EmitSizeAlignOf(E->getArgumentType(), E->getType(), E->isSizeOf());
 266   }
 267
 268   // Unary operators
 269   llvm::Constant *VisitUnaryPlus(const UnaryOperator *E) {
 270     return Visit(E->getSubExpr());
 271   }
 272   llvm::Constant *VisitUnaryMinus(const UnaryOperator *E) {
 273     return llvm::ConstantExpr::getNeg(Visit(E->getSubExpr()));
 274   }
 275   llvm::Constant *VisitUnaryNot(const UnaryOperator *E) {
 276     return llvm::ConstantExpr::getNot(Visit(E->getSubExpr()));
 277   }
 278   llvm::Constant *VisitUnaryLNot(const UnaryOperator *E) {
 279     llvm::Constant *SubExpr = Visit(E->getSubExpr());
 280
 281     if (E->getSubExpr()->getType()->isRealFloatingType()) {
 282       // Compare against 0.0 for fp scalars.
 283       llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType());
 284       SubExpr = llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UEQ, SubExpr,
 285                                             Zero);
 286     } else {
 287       assert((E->getSubExpr()->getType()->isIntegerType() ||
 288               E->getSubExpr()->getType()->isPointerType()) &&
 289              "Unknown scalar type to convert");
 290       // Compare against an integer or pointer null.
 291       llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType());
 292       SubExpr = llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_EQ, SubExpr,
 293                                             Zero);
 294     }
 295
 296     return llvm::ConstantExpr::getZExt(SubExpr, ConvertType(E->getType()));
 297   }
 298   llvm::Constant *VisitUnarySizeOf(const UnaryOperator *E) {
 299     return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), true);
 300   }
 301   llvm::Constant *VisitUnaryAlignOf(const UnaryOperator *E) {
 302     return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), false);
 303   }
 304   llvm::Constant *VisitUnaryAddrOf(const UnaryOperator *E) {
 305     return EmitLValue(E->getSubExpr());
 306   }
 307   llvm::Constant *VisitUnaryOffsetOf(const UnaryOperator *E) {
 308     int64_t Val = E->evaluateOffsetOf(CGM.getContext());
 309
 310     assert(E->getType()->isIntegerType() && "Result type must be an integer!");
 311
 312     uint32_t ResultWidth = static_cast<uint32_t>(
 313       CGM.getContext().getTypeSize(E->getType(), SourceLocation()));
 314     return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
 315   }
 316
 317   // Binary operators
 318   llvm::Constant *VisitBinOr(const BinaryOperator *E) {
 319     llvm::Constant *LHS = Visit(E->getLHS());
 320     llvm::Constant *RHS = Visit(E->getRHS());
 321
 322     return llvm::ConstantExpr::getOr(LHS, RHS);
 323   }
 324   llvm::Constant *VisitBinSub(const BinaryOperator *E) {
 325     llvm::Constant *LHS = Visit(E->getLHS());
 326     llvm::Constant *RHS = Visit(E->getRHS());
 327
 328     if (!isa<llvm::PointerType>(RHS->getType())) {
 329       // pointer - int
 330       if (isa<llvm::PointerType>(LHS->getType())) {
 331         llvm::Constant *Idx = llvm::ConstantExpr::getNeg(RHS);
 332
 333         return llvm::ConstantExpr::getGetElementPtr(LHS, &Idx, 1);
 334       }
 335
 336       // int - int
 337       return llvm::ConstantExpr::getSub(LHS, RHS);
 338     }
 339
 340     assert(0 && "Unhandled bin sub case!");
 341     return 0;
 342   }
 343
 344   llvm::Constant *VisitBinShl(const BinaryOperator *E) {
 345     llvm::Constant *LHS = Visit(E->getLHS());
 346     llvm::Constant *RHS = Visit(E->getRHS());
 347
 348     // LLVM requires the LHS and RHS to be the same type: promote or truncate the
 349     // RHS to the same size as the LHS.
 350     if (LHS->getType() != RHS->getType())
 351       RHS = llvm::ConstantExpr::getIntegerCast(RHS, LHS->getType(), false);
 352
 353     return llvm::ConstantExpr::getShl(LHS, RHS);
 354   }
 355
 356   llvm::Constant *VisitBinMul(const BinaryOperator *E) {
 357     llvm::Constant *LHS = Visit(E->getLHS());
 358     llvm::Constant *RHS = Visit(E->getRHS());
 359
 360     return llvm::ConstantExpr::getMul(LHS, RHS);
 361   }
 362
 363   llvm::Constant *VisitBinDiv(const BinaryOperator *E) {
 364     llvm::Constant *LHS = Visit(E->getLHS());
 365     llvm::Constant *RHS = Visit(E->getRHS());
 366
 367     if (LHS->getType()->isFPOrFPVector())
 368       return llvm::ConstantExpr::getFDiv(LHS, RHS);
 369     else if (E->getType()->isUnsignedIntegerType())
 370       return llvm::ConstantExpr::getUDiv(LHS, RHS);
 371     else
 372       return llvm::ConstantExpr::getSDiv(LHS, RHS);
 373   }
 374
 375   llvm::Constant *VisitBinAdd(const BinaryOperator *E) {
 376     llvm::Constant *LHS = Visit(E->getLHS());
 377     llvm::Constant *RHS = Visit(E->getRHS());
 378
 379     if (!E->getType()->isPointerType())
 380       return llvm::ConstantExpr::getAdd(LHS, RHS);
 381
 382     llvm::Constant *Ptr, *Idx;
 383     if (isa<llvm::PointerType>(LHS->getType())) { // pointer + int
 384       Ptr = LHS;
 385       Idx = RHS;
 386     } else { // int + pointer
 387       Ptr = RHS;
 388       Idx = LHS;
 389     }
 390
 391     return llvm::ConstantExpr::getGetElementPtr(Ptr, &Idx, 1);
 392   }
 393
 394   llvm::Constant *VisitBinAnd(const BinaryOperator *E) {
 395     llvm::Constant *LHS = Visit(E->getLHS());
 396     llvm::Constant *RHS = Visit(E->getRHS());
 397
 398     return llvm::ConstantExpr::getAnd(LHS, RHS);
 399   }
 400
 401   // Utility methods
 402   const llvm::Type *ConvertType(QualType T) {
 403     return CGM.getTypes().ConvertType(T);
 404   }
 405
 406   llvm::Constant *EmitConversionToBool(llvm::Constant *Src, QualType SrcType) {
 407     assert(SrcType->isCanonical() && "EmitConversion strips typedefs");
 408
 409     if (SrcType->isRealFloatingType()) {
 410       // Compare against 0.0 for fp scalars.
 411       llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType());
 412       return llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UNE, Src, Zero);
 413     }
 414
 415     assert((SrcType->isIntegerType() || SrcType->isPointerType()) &&
 416            "Unknown scalar type to convert");
 417
 418     // Compare against an integer or pointer null.
 419     llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType());
 420     return llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_NE, Src, Zero);
 421   }
 422
 423   llvm::Constant *EmitConversion(llvm::Constant *Src, QualType SrcType,
 424                                  QualType DstType) {
 425     SrcType = SrcType.getCanonicalType();
 426     DstType = DstType.getCanonicalType();
 427     if (SrcType == DstType) return Src;
 428
 429     // Handle conversions to bool first, they are special: comparisons against 0.
 430     if (DstType->isBooleanType())
 431       return EmitConversionToBool(Src, SrcType);
 432
 433     const llvm::Type *DstTy = ConvertType(DstType);
 434
 435     // Ignore conversions like int -> uint.
 436     if (Src->getType() == DstTy)
 437       return Src;
 438
 439     // Handle pointer conversions next: pointers can only be converted to/from
 440     // other pointers and integers.
 441     if (isa<PointerType>(DstType)) {
 442       // The source value may be an integer, or a pointer.
 443       if (isa<llvm::PointerType>(Src->getType()))
 444         return llvm::ConstantExpr::getBitCast(Src, DstTy);
 445       assert(SrcType->isIntegerType() &&"Not ptr->ptr or int->ptr conversion?");
 446       return llvm::ConstantExpr::getIntToPtr(Src, DstTy);
 447     }
 448
 449     if (isa<PointerType>(SrcType)) {
 450       // Must be an ptr to int cast.
 451       assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?");
 452       return llvm::ConstantExpr::getPtrToInt(Src, DstTy);
 453     }
 454
 455     // A scalar source can be splatted to a vector of the same element type
 456     if (isa<llvm::VectorType>(DstTy) && !isa<VectorType>(SrcType)) {
 457       const llvm::VectorType *VT = cast<llvm::VectorType>(DstTy);
 458       assert((VT->getElementType() == Src->getType()) &&
 459              "Vector element type must match scalar type to splat.");
 460       unsigned NumElements = DstType->getAsVectorType()->getNumElements();
 461       llvm::SmallVector<llvm::Constant*, 16> Elements;
 462       for (unsigned i = 0; i < NumElements; i++)
 463         Elements.push_back(Src);
 464
 465       return llvm::ConstantVector::get(&Elements[0], NumElements);
 466     }
 467
 468     if (isa<llvm::VectorType>(Src->getType()) ||
 469         isa<llvm::VectorType>(DstTy)) {
 470       return llvm::ConstantExpr::getBitCast(Src, DstTy);
 471     }
 472
 473     // Finally, we have the arithmetic types: real int/float.
 474     if (isa<llvm::IntegerType>(Src->getType())) {
 475       bool InputSigned = SrcType->isSignedIntegerType();
 476       if (isa<llvm::IntegerType>(DstTy))
 477         return llvm::ConstantExpr::getIntegerCast(Src, DstTy, InputSigned);
 478       else if (InputSigned)
 479         return llvm::ConstantExpr::getSIToFP(Src, DstTy);
 480       else
 481         return llvm::ConstantExpr::getUIToFP(Src, DstTy);
 482     }
 483
 484     assert(Src->getType()->isFloatingPoint() && "Unknown real conversion");
 485     if (isa<llvm::IntegerType>(DstTy)) {
 486       if (DstType->isSignedIntegerType())
 487         return llvm::ConstantExpr::getFPToSI(Src, DstTy);
 488       else
 489         return llvm::ConstantExpr::getFPToUI(Src, DstTy);
 490     }
 491
 492     assert(DstTy->isFloatingPoint() && "Unknown real conversion");
 493     if (DstTy->getTypeID() < Src->getType()->getTypeID())
 494       return llvm::ConstantExpr::getFPTrunc(Src, DstTy);
 495     else
 496       return llvm::ConstantExpr::getFPExtend(Src, DstTy);
 497   }
 498
 499   llvm::Constant *EmitSizeAlignOf(QualType TypeToSize,
 500                                   QualType RetType, bool isSizeOf) {
 501     std::pair<uint64_t, unsigned> Info =
 502     CGM.getContext().getTypeInfo(TypeToSize, SourceLocation());
 503
 504     uint64_t Val = isSizeOf ? Info.first : Info.second;
 505     Val /= 8;  // Return size in bytes, not bits.
 506
 507     assert(RetType->isIntegerType() && "Result type must be an integer!");
 508
 509     uint32_t ResultWidth = static_cast<uint32_t>(
 510       CGM.getContext().getTypeSize(RetType, SourceLocation()));
 511     return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
 512   }
 513
 514   llvm::Constant *EmitLValue(Expr *E) {
 515     switch (E->getStmtClass()) {
 516     default: {
 517       CGM.WarnUnsupported(E, "constant l-value expression");
 518       llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
 519       return llvm::UndefValue::get(Ty);
 520     }
 521     case Expr::ParenExprClass:
 522       // Elide parenthesis
 523       return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
 524     case Expr::CompoundLiteralExprClass: {
 525       // Note that due to the nature of compound literals, this is guaranteed
 526       // to be the only use of the variable, so we just generate it here.
 527       CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
 528       llvm::Constant* C = Visit(CLE->getInitializer());
 529       C = new llvm::GlobalVariable(C->getType(),E->getType().isConstQualified(),
 530                                    llvm::GlobalValue::InternalLinkage,
 531                                    C, ".compoundliteral", &CGM.getModule());
 532       return C;
 533     }
 534     case Expr::DeclRefExprClass: {
 535       ValueDecl *Decl = cast<DeclRefExpr>(E)->getDecl();
 536       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
 537         return CGM.GetAddrOfFunctionDecl(FD, false);
 538       if (const VarDecl* VD = dyn_cast<VarDecl>(Decl))
 539         return CGM.GetAddrOfGlobalVar(VD, false);
 540       // We can end up here with static block-scope variables (and others?)
 541       // FIXME: How do we implement block-scope variables?!
 542       assert(0 && "Unimplemented Decl type");
 543       return 0;
 544     }
 545     case Expr::MemberExprClass: {
 546       MemberExpr* ME = cast<MemberExpr>(E);
 547       llvm::Constant *Base;
 548       if (ME->isArrow())
 549         Base = Visit(ME->getBase());
 550       else
 551         Base = EmitLValue(ME->getBase());
 552
 553       unsigned FieldNumber = CGM.getTypes().getLLVMFieldNo(ME->getMemberDecl());
 554       llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
 555       llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty,
 556                                                    FieldNumber);
 557       llvm::Value *Ops[] = {Zero, Idx};
 558       return llvm::ConstantExpr::getGetElementPtr(Base, Ops, 2);
 559     }
 560     case Expr::ArraySubscriptExprClass: {
 561       ArraySubscriptExpr* ASExpr = cast<ArraySubscriptExpr>(E);
 562       llvm::Constant *Base = Visit(ASExpr->getBase());
 563       llvm::Constant *Index = Visit(ASExpr->getIdx());
 564       assert(!ASExpr->getBase()->getType()->isVectorType() &&
 565              "Taking the address of a vector component is illegal!");
 566       return llvm::ConstantExpr::getGetElementPtr(Base, &Index, 1);
 567     }
 568     case Expr::StringLiteralClass: {
 569       StringLiteral *String = cast<StringLiteral>(E);
 570       assert(!String->isWide() && "Cannot codegen wide strings yet");
 571       const char *StrData = String->getStrData();
 572       unsigned Len = String->getByteLength();
 573
 574       return CGM.GetAddrOfConstantString(std::string(StrData, StrData + Len));
 575     }
 576     case Expr::UnaryOperatorClass: {
 577       UnaryOperator *Exp = cast<UnaryOperator>(E);
 578       switch (Exp->getOpcode()) {
 579         default: assert(0 && "Unsupported unary operator.");
 580         case UnaryOperator::Extension:
 581         // Extension is just a wrapper for expressions
 582         return EmitLValue(Exp->getSubExpr());
 583       case UnaryOperator::Real:
 584       case UnaryOperator::Imag: {
 585         // The address of __real or __imag is just a GEP off the address
 586         // of the internal expression
 587         llvm::Constant* C = EmitLValue(Exp->getSubExpr());
 588         llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
 589         llvm::Constant *Idx  = llvm::ConstantInt::get(llvm::Type::Int32Ty,
 590                                        Exp->getOpcode() == UnaryOperator::Imag);
 591         llvm::Value *Ops[] = {Zero, Idx};
 592         return llvm::ConstantExpr::getGetElementPtr(C, Ops, 2);
 593       }
 594       case UnaryOperator::Deref:
 595         // The address of a deref is just the value of the expression
 596         return Visit(Exp->getSubExpr());
 597       }
 598     }
 599     }
 600   }
 601
 602 };
 603
 604 }  // end anonymous namespace.
 605
 606
 607 llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E)
 608 {
 609   QualType type = E->getType().getCanonicalType();
 610
 611   if (type->isIntegerType()) {
 612     llvm::APSInt
 613     Value(static_cast<uint32_t>(Context.getTypeSize(type, SourceLocation())));
 614     if (E->isIntegerConstantExpr(Value, Context)) {
 615       return llvm::ConstantInt::get(Value);
 616     }
 617   }
 618
 619   return ConstExprEmitter(*this).Visit(const_cast<Expr*>(E));
 620 }