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