CGExprConstant.cpp revision 704e4907ee0116e53f270d778c955da9f01fc2d8 
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 "CGObjCRuntime.h"
17#include "clang/AST/APValue.h"
18#include "clang/AST/ASTContext.h"
19#include "clang/AST/StmtVisitor.h"
20#include "llvm/Constants.h"
21#include "llvm/Function.h"
22#include "llvm/GlobalVariable.h"
23#include "llvm/Support/Compiler.h"
24#include "llvm/Target/TargetData.h"
25using namespace clang;
26using namespace CodeGen;
27
28namespace  {
29class VISIBILITY_HIDDEN ConstExprEmitter :
30  public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
31  CodeGenModule &CGM;
32  CodeGenFunction *CGF;
33public:
34  ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf)
35    : CGM(cgm), CGF(cgf) {
36  }
37
38  //===--------------------------------------------------------------------===//
39  //                            Visitor Methods
40  //===--------------------------------------------------------------------===//
41
42  llvm::Constant *VisitStmt(Stmt *S) {
43    CGM.ErrorUnsupported(S, "constant expression");
44    QualType T = cast<Expr>(S)->getType();
45    return llvm::UndefValue::get(CGM.getTypes().ConvertType(T));
46  }
47
48  llvm::Constant *VisitParenExpr(ParenExpr *PE) {
49    return Visit(PE->getSubExpr());
50  }
51
52  llvm::Constant *VisitObjCStringLiteral(const ObjCStringLiteral *E) {
53    std::string S(E->getString()->getStrData(),
54                  E->getString()->getByteLength());
55    llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(S);
56    return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType()));
57  }
58
59  llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
60    return Visit(E->getInitializer());
61  }
62
63  llvm::Constant *VisitCastExpr(CastExpr* E) {
64    llvm::Constant *C = Visit(E->getSubExpr());
65
66    return EmitConversion(C, E->getSubExpr()->getType(), E->getType());
67  }
68
69  llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
70    return Visit(DAE->getExpr());
71  }
72
73  llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) {
74    std::vector<llvm::Constant*> Elts;
75    const llvm::ArrayType *AType =
76        cast<llvm::ArrayType>(ConvertType(ILE->getType()));
77    unsigned NumInitElements = ILE->getNumInits();
78    // FIXME: Check for wide strings
79    if (NumInitElements > 0 && isa<StringLiteral>(ILE->getInit(0)) &&
80        ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType())
81      return Visit(ILE->getInit(0));
82    const llvm::Type *ElemTy = AType->getElementType();
83    unsigned NumElements = AType->getNumElements();
84
85    // Initialising an array requires us to automatically
86    // initialise any elements that have not been initialised explicitly
87    unsigned NumInitableElts = std::min(NumInitElements, NumElements);
88
89    // Copy initializer elements.
90    unsigned i = 0;
91    bool RewriteType = false;
92    for (; i < NumInitableElts; ++i) {
93      llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF);
94      RewriteType |= (C->getType() != ElemTy);
95      Elts.push_back(C);
96    }
97
98    // Initialize remaining array elements.
99    for (; i < NumElements; ++i)
100      Elts.push_back(llvm::Constant::getNullValue(ElemTy));
101
102    if (RewriteType) {
103      // FIXME: Try to avoid packing the array
104      std::vector<const llvm::Type*> Types;
105      for (unsigned i = 0; i < Elts.size(); ++i)
106        Types.push_back(Elts[i]->getType());
107      const llvm::StructType *SType = llvm::StructType::get(Types, true);
108      return llvm::ConstantStruct::get(SType, Elts);
109    }
110
111    return llvm::ConstantArray::get(AType, Elts);
112  }
113
114  void InsertBitfieldIntoStruct(std::vector<llvm::Constant*>& Elts,
115                                FieldDecl* Field, Expr* E) {
116    // Calculate the value to insert
117    llvm::Constant *C = CGM.EmitConstantExpr(E, CGF);
118    llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C);
119    if (!CI) {
120      CGM.ErrorUnsupported(E, "bitfield initialization");
121      return;
122    }
123    llvm::APInt V = CI->getValue();
124
125    // Calculate information about the relevant field
126    const llvm::Type* Ty = CI->getType();
127    const llvm::TargetData &TD = CGM.getTypes().getTargetData();
128    unsigned size = TD.getTypeStoreSizeInBits(Ty);
129    unsigned fieldOffset = CGM.getTypes().getLLVMFieldNo(Field) * size;
130    CodeGenTypes::BitFieldInfo bitFieldInfo =
131        CGM.getTypes().getBitFieldInfo(Field);
132    fieldOffset += bitFieldInfo.Begin;
133
134    // Find where to start the insertion
135    // FIXME: This is O(n^2) in the number of bit-fields!
136    // FIXME: This won't work if the struct isn't completely packed!
137    unsigned offset = 0, i = 0;
138    while (offset < (fieldOffset & -8))
139      offset += TD.getTypeStoreSizeInBits(Elts[i++]->getType());
140
141    // Advance over 0 sized elements (must terminate in bounds since
142    // the bitfield must have a size).
143    while (TD.getTypeStoreSizeInBits(Elts[i]->getType()) == 0)
144      ++i;
145
146    // Promote the size of V if necessary
147    // FIXME: This should never occur, but currently it can because
148    // initializer constants are cast to bool, and because clang is
149    // not enforcing bitfield width limits.
150    if (bitFieldInfo.Size > V.getBitWidth())
151      V.zext(bitFieldInfo.Size);
152
153    // Insert the bits into the struct
154    // FIXME: This algorthm is only correct on X86!
155    // FIXME: THis algorthm assumes bit-fields only have byte-size elements!
156    unsigned bitsToInsert = bitFieldInfo.Size;
157    unsigned curBits = std::min(8 - (fieldOffset & 7), bitsToInsert);
158    unsigned byte = V.getLoBits(curBits).getZExtValue() << (fieldOffset & 7);
159    do {
160      llvm::Constant* byteC = llvm::ConstantInt::get(llvm::Type::Int8Ty, byte);
161      Elts[i] = llvm::ConstantExpr::getOr(Elts[i], byteC);
162      ++i;
163      V = V.lshr(curBits);
164      bitsToInsert -= curBits;
165
166      if (!bitsToInsert)
167        break;
168
169      curBits = bitsToInsert > 8 ? 8 : bitsToInsert;
170      byte = V.getLoBits(curBits).getZExtValue();
171    } while (true);
172  }
173
174  llvm::Constant *EmitStructInitialization(InitListExpr *ILE) {
175    const llvm::StructType *SType =
176        cast<llvm::StructType>(ConvertType(ILE->getType()));
177    RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl();
178    std::vector<llvm::Constant*> Elts;
179
180    // Initialize the whole structure to zero.
181    for (unsigned i = 0; i < SType->getNumElements(); ++i) {
182      const llvm::Type *FieldTy = SType->getElementType(i);
183      Elts.push_back(llvm::Constant::getNullValue(FieldTy));
184    }
185
186    // Copy initializer elements. Skip padding fields.
187    unsigned EltNo = 0;  // Element no in ILE
188    int FieldNo = 0; // Field no in RecordDecl
189    bool RewriteType = false;
190    while (EltNo < ILE->getNumInits() && FieldNo < RD->getNumMembers()) {
191      FieldDecl* curField = RD->getMember(FieldNo);
192      FieldNo++;
193      if (!curField->getIdentifier())
194        continue;
195
196      if (curField->isBitField()) {
197        InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(EltNo));
198      } else {
199        unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(curField);
200        llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(EltNo), CGF);
201        RewriteType |= (C->getType() != Elts[FieldNo]->getType());
202        Elts[FieldNo] = C;
203      }
204      EltNo++;
205    }
206
207    if (RewriteType) {
208      // FIXME: Make this work for non-packed structs
209      assert(SType->isPacked() && "Cannot recreate unpacked structs");
210      std::vector<const llvm::Type*> Types;
211      for (unsigned i = 0; i < Elts.size(); ++i)
212        Types.push_back(Elts[i]->getType());
213      SType = llvm::StructType::get(Types, true);
214    }
215
216    return llvm::ConstantStruct::get(SType, Elts);
217  }
218
219  llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) {
220    RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl();
221    const llvm::Type *Ty = ConvertType(ILE->getType());
222
223    // Find the field decl we're initializing, if any
224    int FieldNo = 0; // Field no in RecordDecl
225    FieldDecl* curField = 0;
226    while (FieldNo < RD->getNumMembers()) {
227      curField = RD->getMember(FieldNo);
228      FieldNo++;
229      if (curField->getIdentifier())
230        break;
231    }
232
233    if (!curField || !curField->getIdentifier() || ILE->getNumInits() == 0)
234      return llvm::Constant::getNullValue(Ty);
235
236    if (curField->isBitField()) {
237      // Create a dummy struct for bit-field insertion
238      unsigned NumElts = CGM.getTargetData().getABITypeSize(Ty) / 8;
239      llvm::Constant* NV = llvm::Constant::getNullValue(llvm::Type::Int8Ty);
240      std::vector<llvm::Constant*> Elts(NumElts, NV);
241
242      InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(0));
243      const llvm::ArrayType *RetTy =
244          llvm::ArrayType::get(NV->getType(), NumElts);
245      return llvm::ConstantArray::get(RetTy, Elts);
246    }
247
248    llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(0), CGF);
249
250    // Build a struct with the union sub-element as the first member,
251    // and padded to the appropriate size
252    std::vector<llvm::Constant*> Elts;
253    std::vector<const llvm::Type*> Types;
254    Elts.push_back(C);
255    Types.push_back(C->getType());
256    unsigned CurSize = CGM.getTargetData().getTypeStoreSize(C->getType());
257    unsigned TotalSize = CGM.getTargetData().getTypeStoreSize(Ty);
258    while (CurSize < TotalSize) {
259      Elts.push_back(llvm::Constant::getNullValue(llvm::Type::Int8Ty));
260      Types.push_back(llvm::Type::Int8Ty);
261      CurSize++;
262    }
263
264    // This always generates a packed struct
265    // FIXME: Try to generate an unpacked struct when we can
266    llvm::StructType* STy = llvm::StructType::get(Types, true);
267    return llvm::ConstantStruct::get(STy, Elts);
268  }
269
270  llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) {
271    const llvm::VectorType *VType =
272        cast<llvm::VectorType>(ConvertType(ILE->getType()));
273    const llvm::Type *ElemTy = VType->getElementType();
274    std::vector<llvm::Constant*> Elts;
275    unsigned NumElements = VType->getNumElements();
276    unsigned NumInitElements = ILE->getNumInits();
277
278    unsigned NumInitableElts = std::min(NumInitElements, NumElements);
279
280    // Copy initializer elements.
281    unsigned i = 0;
282    for (; i < NumInitableElts; ++i) {
283      llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF);
284      Elts.push_back(C);
285    }
286
287    for (; i < NumElements; ++i)
288      Elts.push_back(llvm::Constant::getNullValue(ElemTy));
289
290    return llvm::ConstantVector::get(VType, Elts);
291  }
292
293  llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
294    if (ILE->getType()->isScalarType()) {
295      // We have a scalar in braces. Just use the first element.
296      if (ILE->getNumInits() > 0)
297        return CGM.EmitConstantExpr(ILE->getInit(0), CGF);
298
299      const llvm::Type* RetTy = CGM.getTypes().ConvertType(ILE->getType());
300      return llvm::Constant::getNullValue(RetTy);
301    }
302
303    // FIXME: We don't codegen or sema designators yet.
304    if (ILE->hadDesignators()) {
305      CGM.ErrorUnsupported(ILE, "initializer list with designators");
306      return llvm::UndefValue::get(ConvertType(ILE->getType()));
307    }
308
309    if (ILE->getType()->isArrayType())
310      return EmitArrayInitialization(ILE);
311
312    if (ILE->getType()->isStructureType())
313      return EmitStructInitialization(ILE);
314
315    if (ILE->getType()->isUnionType())
316      return EmitUnionInitialization(ILE);
317
318    if (ILE->getType()->isVectorType())
319      return EmitVectorInitialization(ILE);
320
321    assert(0 && "Unable to handle InitListExpr");
322    // Get rid of control reaches end of void function warning.
323    // Not reached.
324    return 0;
325  }
326
327  llvm::Constant *VisitImplicitCastExpr(ImplicitCastExpr *ICExpr) {
328    Expr* SExpr = ICExpr->getSubExpr();
329    QualType SType = SExpr->getType();
330    llvm::Constant *C; // the intermediate expression
331    QualType T;        // the type of the intermediate expression
332    if (SType->isArrayType()) {
333      // Arrays decay to a pointer to the first element
334      // VLAs would require special handling, but they can't occur here
335      C = EmitLValue(SExpr);
336      llvm::Constant *Idx0 = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
337      llvm::Constant *Ops[] = {Idx0, Idx0};
338      C = llvm::ConstantExpr::getGetElementPtr(C, Ops, 2);
339      T = CGM.getContext().getArrayDecayedType(SType);
340    } else if (SType->isFunctionType()) {
341      // Function types decay to a pointer to the function
342      C = EmitLValue(SExpr);
343      T = CGM.getContext().getPointerType(SType);
344    } else {
345      C = Visit(SExpr);
346      T = SType;
347    }
348
349    // Perform the conversion; note that an implicit cast can both promote
350    // and convert an array/function
351    return EmitConversion(C, T, ICExpr->getType());
352  }
353
354  llvm::Constant *VisitStringLiteral(StringLiteral *E) {
355    assert(!E->getType()->isPointerType() && "Strings are always arrays");
356
357    // Otherwise this must be a string initializing an array in a static
358    // initializer.  Don't emit it as the address of the string, emit the string
359    // data itself as an inline array.
360    return llvm::ConstantArray::get(CGM.GetStringForStringLiteral(E), false);
361  }
362
363  llvm::Constant *VisitAddrLabelExpr(const AddrLabelExpr *E) {
364    assert(CGF && "Invalid address of label expression outside function.");
365    llvm::Constant *C =
366      llvm::ConstantInt::get(llvm::Type::Int32Ty,
367                             CGF->GetIDForAddrOfLabel(E->getLabel()));
368    return llvm::ConstantExpr::getIntToPtr(C, ConvertType(E->getType()));
369  }
370
371  llvm::Constant *VisitUnaryAddrOf(const UnaryOperator *E) {
372    return EmitLValue(E->getSubExpr());
373  }
374  llvm::Constant *VisitUnaryOffsetOf(const UnaryOperator *E) {
375    int64_t Val = E->evaluateOffsetOf(CGM.getContext());
376
377    assert(E->getType()->isIntegerType() && "Result type must be an integer!");
378
379    uint32_t ResultWidth =
380      static_cast<uint32_t>(CGM.getContext().getTypeSize(E->getType()));
381    return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
382  }
383
384  llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) {
385    return Visit(E->getSubExpr());
386  }
387
388  // Binary operators
389
390  llvm::Constant *VisitCallExpr(const CallExpr *E) {
391    APValue Result;
392    if (E->Evaluate(Result, CGM.getContext())) {
393      if (Result.isInt())
394        return llvm::ConstantInt::get(Result.getInt());
395      if (Result.isFloat())
396        return llvm::ConstantFP::get(Result.getFloat());
397    }
398
399    // Handle __builtin___CFStringMakeConstantString.
400    if (E->isBuiltinCall() ==Builtin::BI__builtin___CFStringMakeConstantString){
401      const Expr *Arg = E->getArg(0)->IgnoreParenCasts();
402
403      const StringLiteral *Literal = cast<StringLiteral>(Arg);
404      std::string S(Literal->getStrData(), Literal->getByteLength());
405      return CGM.GetAddrOfConstantCFString(S);
406    }
407
408    CGM.ErrorUnsupported(E, "constant call expression");
409    return llvm::Constant::getNullValue(ConvertType(E->getType()));
410  }
411
412  // Utility methods
413  const llvm::Type *ConvertType(QualType T) {
414    return CGM.getTypes().ConvertType(T);
415  }
416
417  llvm::Constant *EmitConversionToBool(llvm::Constant *Src, QualType SrcType) {
418    assert(SrcType->isCanonical() && "EmitConversion strips typedefs");
419
420    if (SrcType->isRealFloatingType()) {
421      // Compare against 0.0 for fp scalars.
422      llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType());
423      return llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UNE, Src, Zero);
424    }
425
426    assert((SrcType->isIntegerType() || SrcType->isPointerType()) &&
427           "Unknown scalar type to convert");
428
429    // Compare against an integer or pointer null.
430    llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType());
431    return llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_NE, Src, Zero);
432  }
433
434  llvm::Constant *EmitConversion(llvm::Constant *Src, QualType SrcType,
435                                 QualType DstType) {
436    SrcType = CGM.getContext().getCanonicalType(SrcType);
437    DstType = CGM.getContext().getCanonicalType(DstType);
438    if (SrcType == DstType) return Src;
439
440    // Handle conversions to bool first, they are special: comparisons against 0.
441    if (DstType->isBooleanType())
442      return EmitConversionToBool(Src, SrcType);
443
444    const llvm::Type *DstTy = ConvertType(DstType);
445
446    // Ignore conversions like int -> uint.
447    if (Src->getType() == DstTy)
448      return Src;
449
450    // Handle pointer conversions next: pointers can only be converted to/from
451    // other pointers and integers.
452    if (isa<llvm::PointerType>(DstTy)) {
453      // The source value may be an integer, or a pointer.
454      if (isa<llvm::PointerType>(Src->getType()))
455        return llvm::ConstantExpr::getBitCast(Src, DstTy);
456      assert(SrcType->isIntegerType() &&"Not ptr->ptr or int->ptr conversion?");
457      return llvm::ConstantExpr::getIntToPtr(Src, DstTy);
458    }
459
460    if (isa<llvm::PointerType>(Src->getType())) {
461      // Must be an ptr to int cast.
462      assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?");
463      return llvm::ConstantExpr::getPtrToInt(Src, DstTy);
464    }
465
466    // A scalar source can be splatted to a vector of the same element type
467    if (isa<llvm::VectorType>(DstTy) && !isa<VectorType>(SrcType)) {
468      assert((cast<llvm::VectorType>(DstTy)->getElementType()
469              == Src->getType()) &&
470             "Vector element type must match scalar type to splat.");
471      unsigned NumElements = DstType->getAsVectorType()->getNumElements();
472      llvm::SmallVector<llvm::Constant*, 16> Elements;
473      for (unsigned i = 0; i < NumElements; i++)
474        Elements.push_back(Src);
475
476      return llvm::ConstantVector::get(&Elements[0], NumElements);
477    }
478
479    if (isa<llvm::VectorType>(Src->getType()) ||
480        isa<llvm::VectorType>(DstTy)) {
481      return llvm::ConstantExpr::getBitCast(Src, DstTy);
482    }
483
484    // Finally, we have the arithmetic types: real int/float.
485    if (isa<llvm::IntegerType>(Src->getType())) {
486      bool InputSigned = SrcType->isSignedIntegerType();
487      if (isa<llvm::IntegerType>(DstTy))
488        return llvm::ConstantExpr::getIntegerCast(Src, DstTy, InputSigned);
489      else if (InputSigned)
490        return llvm::ConstantExpr::getSIToFP(Src, DstTy);
491      else
492        return llvm::ConstantExpr::getUIToFP(Src, DstTy);
493    }
494
495    assert(Src->getType()->isFloatingPoint() && "Unknown real conversion");
496    if (isa<llvm::IntegerType>(DstTy)) {
497      if (DstType->isSignedIntegerType())
498        return llvm::ConstantExpr::getFPToSI(Src, DstTy);
499      else
500        return llvm::ConstantExpr::getFPToUI(Src, DstTy);
501    }
502
503    assert(DstTy->isFloatingPoint() && "Unknown real conversion");
504    if (DstTy->getTypeID() < Src->getType()->getTypeID())
505      return llvm::ConstantExpr::getFPTrunc(Src, DstTy);
506    else
507      return llvm::ConstantExpr::getFPExtend(Src, DstTy);
508  }
509
510  llvm::Constant *EmitSizeAlignOf(QualType TypeToSize,
511                                  QualType RetType, bool isSizeOf) {
512    std::pair<uint64_t, unsigned> Info =
513      CGM.getContext().getTypeInfo(TypeToSize);
514
515    uint64_t Val = isSizeOf ? Info.first : Info.second;
516    Val /= 8;  // Return size in bytes, not bits.
517
518    assert(RetType->isIntegerType() && "Result type must be an integer!");
519
520    uint32_t ResultWidth =
521      static_cast<uint32_t>(CGM.getContext().getTypeSize(RetType));
522    return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
523  }
524
525public:
526  llvm::Constant *EmitLValue(Expr *E) {
527    switch (E->getStmtClass()) {
528    default: break;
529    case Expr::ParenExprClass:
530      // Elide parenthesis
531      return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
532    case Expr::CompoundLiteralExprClass: {
533      // Note that due to the nature of compound literals, this is guaranteed
534      // to be the only use of the variable, so we just generate it here.
535      CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
536      llvm::Constant* C = Visit(CLE->getInitializer());
537      C = new llvm::GlobalVariable(C->getType(),E->getType().isConstQualified(),
538                                   llvm::GlobalValue::InternalLinkage,
539                                   C, ".compoundliteral", &CGM.getModule());
540      return C;
541    }
542    case Expr::DeclRefExprClass: {
543      NamedDecl *Decl = cast<DeclRefExpr>(E)->getDecl();
544      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
545        return CGM.GetAddrOfFunction(FD);
546      if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) {
547        if (VD->isFileVarDecl())
548          return CGM.GetAddrOfGlobalVar(VD);
549        else if (VD->isBlockVarDecl()) {
550          assert(CGF && "Can't access static local vars without CGF");
551          return CGF->GetAddrOfStaticLocalVar(VD);
552        }
553      }
554      break;
555    }
556    case Expr::MemberExprClass: {
557      MemberExpr* ME = cast<MemberExpr>(E);
558      llvm::Constant *Base;
559      if (ME->isArrow())
560        Base = Visit(ME->getBase());
561      else
562        Base = EmitLValue(ME->getBase());
563
564      unsigned FieldNumber = CGM.getTypes().getLLVMFieldNo(ME->getMemberDecl());
565      llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
566      llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty,
567                                                   FieldNumber);
568      llvm::Value *Ops[] = {Zero, Idx};
569      return llvm::ConstantExpr::getGetElementPtr(Base, Ops, 2);
570    }
571    case Expr::ArraySubscriptExprClass: {
572      ArraySubscriptExpr* ASExpr = cast<ArraySubscriptExpr>(E);
573      llvm::Constant *Base = Visit(ASExpr->getBase());
574      llvm::Constant *Index = Visit(ASExpr->getIdx());
575      assert(!ASExpr->getBase()->getType()->isVectorType() &&
576             "Taking the address of a vector component is illegal!");
577      return llvm::ConstantExpr::getGetElementPtr(Base, &Index, 1);
578    }
579    case Expr::StringLiteralClass:
580      return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E));
581    case Expr::ObjCStringLiteralClass: {
582      ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E);
583      std::string S(SL->getString()->getStrData(),
584                    SL->getString()->getByteLength());
585      llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(S);
586      return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType()));
587    }
588    case Expr::UnaryOperatorClass: {
589      UnaryOperator *Exp = cast<UnaryOperator>(E);
590      switch (Exp->getOpcode()) {
591      default: break;
592      case UnaryOperator::Extension:
593        // Extension is just a wrapper for expressions
594        return EmitLValue(Exp->getSubExpr());
595      case UnaryOperator::Real:
596      case UnaryOperator::Imag: {
597        // The address of __real or __imag is just a GEP off the address
598        // of the internal expression
599        llvm::Constant* C = EmitLValue(Exp->getSubExpr());
600        llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
601        llvm::Constant *Idx  = llvm::ConstantInt::get(llvm::Type::Int32Ty,
602                                       Exp->getOpcode() == UnaryOperator::Imag);
603        llvm::Value *Ops[] = {Zero, Idx};
604        return llvm::ConstantExpr::getGetElementPtr(C, Ops, 2);
605      }
606      case UnaryOperator::Deref:
607        // The address of a deref is just the value of the expression
608        return Visit(Exp->getSubExpr());
609      }
610      break;
611    }
612    }
613    CGM.ErrorUnsupported(E, "constant l-value expression");
614    llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
615    return llvm::UndefValue::get(Ty);
616  }
617};
618
619}  // end anonymous namespace.
620
621llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
622                                                CodeGenFunction *CGF) {
623  QualType type = Context.getCanonicalType(E->getType());
624
625  APValue V;
626  if (E->Evaluate(V, Context)) {
627    // FIXME: Assert that the value doesn't have any side effects.
628    switch (V.getKind()) {
629    default: assert(0 && "unhandled value kind!");
630    case APValue::LValue: {
631      llvm::Constant *Offset = llvm::ConstantInt::get(llvm::Type::Int64Ty,
632                                                      V.getLValueOffset());
633
634      if (const Expr *LVBase = V.getLValueBase()) {
635        llvm::Constant *C =
636          ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase));
637
638        const llvm::Type *Type =
639          llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
640        const llvm::Type *DestType = getTypes().ConvertTypeForMem(E->getType());
641
642        // FIXME: It's a little ugly that we need to cast to a pointer,
643        // apply the GEP and then cast back.
644        C = llvm::ConstantExpr::getBitCast(C, Type);
645        C = llvm::ConstantExpr::getGetElementPtr(C, &Offset, 1);
646
647        return llvm::ConstantExpr::getBitCast(C, DestType);
648      }
649
650      return llvm::ConstantExpr::getIntToPtr(Offset,
651                                             getTypes().ConvertType(type));
652    }
653    case APValue::Int: {
654      llvm::Constant *C = llvm::ConstantInt::get(V.getInt());
655
656      if (C->getType() == llvm::Type::Int1Ty) {
657        const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
658        C = llvm::ConstantExpr::getZExt(C, BoolTy);
659      }
660      return C;
661    }
662    case APValue::Float:
663      return llvm::ConstantFP::get(V.getFloat());
664    case APValue::ComplexFloat: {
665      llvm::Constant *Complex[2];
666
667      Complex[0] = llvm::ConstantFP::get(V.getComplexFloatReal());
668      Complex[1] = llvm::ConstantFP::get(V.getComplexFloatImag());
669
670      return llvm::ConstantStruct::get(Complex, 2);
671    }
672    }
673  }
674
675  llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
676  if (C->getType() == llvm::Type::Int1Ty) {
677    const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
678    C = llvm::ConstantExpr::getZExt(C, BoolTy);
679  }
680  return C;
681}
682