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