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