CGExprConstant.cpp revision 0032b2781b4deb131f8c9b7968f2030bf2489cdd 
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/RecordLayout.h"
20#include "clang/AST/StmtVisitor.h"
21#include "clang/Basic/Builtins.h"
22#include "llvm/Constants.h"
23#include "llvm/Function.h"
24#include "llvm/GlobalVariable.h"
25#include "llvm/Support/Compiler.h"
26#include "llvm/Target/TargetData.h"
27using namespace clang;
28using namespace CodeGen;
29
30namespace  {
31
32class VISIBILITY_HIDDEN ConstStructBuilder {
33  CodeGenModule &CGM;
34  CodeGenFunction *CGF;
35
36  bool Packed;
37
38  unsigned NextFieldOffsetInBytes;
39
40  std::vector<llvm::Constant *> Elements;
41
42  ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF)
43    : CGM(CGM), CGF(CGF), Packed(false), NextFieldOffsetInBytes(0) { }
44
45  bool AppendField(const FieldDecl *Field, uint64_t FieldOffset,
46                   const Expr *InitExpr) {
47    uint64_t FieldOffsetInBytes = FieldOffset / 8;
48
49    assert(NextFieldOffsetInBytes <= FieldOffsetInBytes
50           && "Field offset mismatch!");
51
52    // Emit the field.
53    llvm::Constant *C = CGM.EmitConstantExpr(InitExpr, Field->getType(), CGF);
54    if (!C)
55      return false;
56
57    unsigned FieldAlignment = getAlignment(C);
58
59    // Round up the field offset to the alignment of the field type.
60    uint64_t AlignedNextFieldOffsetInBytes =
61      llvm::RoundUpToAlignment(NextFieldOffsetInBytes, FieldAlignment);
62
63    if (AlignedNextFieldOffsetInBytes > FieldOffsetInBytes) {
64      std::vector<llvm::Constant *> PackedElements;
65
66      assert(!Packed && "Alignment is wrong even with a packed struct!");
67
68      // Convert the struct to a packed struct.
69      uint64_t ElementOffsetInBytes = 0;
70
71      for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
72        llvm::Constant *C = Elements[i];
73
74        unsigned ElementAlign =
75          CGM.getTargetData().getABITypeAlignment(C->getType());
76        uint64_t AlignedElementOffsetInBytes =
77          llvm::RoundUpToAlignment(ElementOffsetInBytes, ElementAlign);
78
79        if (AlignedElementOffsetInBytes > ElementOffsetInBytes) {
80          // We need some padding.
81          uint64_t NumBytes =
82            AlignedElementOffsetInBytes - ElementOffsetInBytes;
83
84          const llvm::Type *Ty = llvm::Type::getInt8Ty(CGF->getLLVMContext());
85          if (NumBytes > 1)
86            Ty = llvm::ArrayType::get(Ty, NumBytes);
87
88          llvm::Constant *Padding = llvm::Constant::getNullValue(Ty);
89          PackedElements.push_back(Padding);
90          ElementOffsetInBytes += getSizeInBytes(Padding);
91        }
92
93        PackedElements.push_back(C);
94        ElementOffsetInBytes += getSizeInBytes(C);
95      }
96
97      assert(ElementOffsetInBytes == NextFieldOffsetInBytes &&
98             "Packing the struct changed its size!");
99
100      Elements = PackedElements;
101      Packed = true;
102      AlignedNextFieldOffsetInBytes = NextFieldOffsetInBytes;
103    }
104
105    if (AlignedNextFieldOffsetInBytes < FieldOffsetInBytes) {
106      // We need to append padding.
107      AppendPadding(FieldOffsetInBytes - NextFieldOffsetInBytes);
108
109      assert(NextFieldOffsetInBytes == FieldOffsetInBytes &&
110             "Did not add enough padding!");
111
112      AlignedNextFieldOffsetInBytes = NextFieldOffsetInBytes;
113    }
114
115    // Add the field.
116    Elements.push_back(C);
117    NextFieldOffsetInBytes = AlignedNextFieldOffsetInBytes + getSizeInBytes(C);
118
119    return true;
120  }
121
122  bool AppendBitField(const FieldDecl *Field, uint64_t FieldOffset,
123                      const Expr *InitExpr) {
124    llvm::ConstantInt *CI =
125      cast_or_null<llvm::ConstantInt>(CGM.EmitConstantExpr(InitExpr,
126                                                           Field->getType(),
127                                                           CGF));
128    // FIXME: Can this ever happen?
129    if (!CI)
130      return false;
131
132    if (FieldOffset > NextFieldOffsetInBytes * 8) {
133      // We need to add padding.
134      uint64_t NumBytes =
135        llvm::RoundUpToAlignment(FieldOffset -
136                                 NextFieldOffsetInBytes * 8, 8) / 8;
137
138      AppendPadding(NumBytes);
139    }
140
141    uint64_t FieldSize =
142      Field->getBitWidth()->EvaluateAsInt(CGM.getContext()).getZExtValue();
143
144    llvm::APInt FieldValue = CI->getValue();
145
146    // Promote the size of FieldValue if necessary
147    // FIXME: This should never occur, but currently it can because initializer
148    // constants are cast to bool, and because clang is not enforcing bitfield
149    // width limits.
150    if (FieldSize > FieldValue.getBitWidth())
151      FieldValue.zext(FieldSize);
152
153    // Truncate the size of FieldValue to the bit field size.
154    if (FieldSize < FieldValue.getBitWidth())
155      FieldValue.trunc(FieldSize);
156
157    if (FieldOffset < NextFieldOffsetInBytes * 8) {
158      // Either part of the field or the entire field can go into the previous
159      // byte.
160      assert(!Elements.empty() && "Elements can't be empty!");
161
162      unsigned BitsInPreviousByte =
163        NextFieldOffsetInBytes * 8 - FieldOffset;
164
165      bool FitsCompletelyInPreviousByte =
166        BitsInPreviousByte >= FieldValue.getBitWidth();
167
168      llvm::APInt Tmp = FieldValue;
169
170      if (!FitsCompletelyInPreviousByte) {
171        unsigned NewFieldWidth = FieldSize - BitsInPreviousByte;
172
173        if (CGM.getTargetData().isBigEndian()) {
174          Tmp = Tmp.lshr(NewFieldWidth);
175          Tmp.trunc(BitsInPreviousByte);
176
177          // We want the remaining high bits.
178          FieldValue.trunc(NewFieldWidth);
179        } else {
180          Tmp.trunc(BitsInPreviousByte);
181
182          // We want the remaining low bits.
183          FieldValue = FieldValue.lshr(BitsInPreviousByte);
184          FieldValue.trunc(NewFieldWidth);
185        }
186      }
187
188      Tmp.zext(8);
189      if (CGM.getTargetData().isBigEndian()) {
190        if (FitsCompletelyInPreviousByte)
191          Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth());
192      } else {
193        Tmp = Tmp.shl(8 - BitsInPreviousByte);
194      }
195
196      // Or in the bits that go into the previous byte.
197      Tmp |= cast<llvm::ConstantInt>(Elements.back())->getValue();
198      Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp);
199
200      if (FitsCompletelyInPreviousByte)
201        return true;
202    }
203
204    while (FieldValue.getBitWidth() > 8) {
205      llvm::APInt Tmp;
206
207      if (CGM.getTargetData().isBigEndian()) {
208        // We want the high bits.
209        Tmp = FieldValue;
210        Tmp = Tmp.lshr(Tmp.getBitWidth() - 8);
211        Tmp.trunc(8);
212      } else {
213        // We want the low bits.
214        Tmp = FieldValue;
215        Tmp.trunc(8);
216
217        FieldValue = FieldValue.lshr(8);
218      }
219
220      Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp));
221      NextFieldOffsetInBytes++;
222
223      FieldValue.trunc(FieldValue.getBitWidth() - 8);
224    }
225
226    assert(FieldValue.getBitWidth() > 0 &&
227           "Should have at least one bit left!");
228    assert(FieldValue.getBitWidth() <= 8 &&
229           "Should not have more than a byte left!");
230
231    if (FieldValue.getBitWidth() < 8) {
232      if (CGM.getTargetData().isBigEndian()) {
233        unsigned BitWidth = FieldValue.getBitWidth();
234
235        FieldValue.zext(8);
236        FieldValue = FieldValue << (8 - BitWidth);
237      } else
238        FieldValue.zext(8);
239    }
240
241    // Append the last element.
242    Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(),
243                                              FieldValue));
244    NextFieldOffsetInBytes++;
245    return true;
246  }
247
248  void AppendPadding(uint64_t NumBytes) {
249    if (!NumBytes)
250      return;
251
252    const llvm::Type *Ty = llvm::Type::getInt8Ty(CGM.getLLVMContext());
253    if (NumBytes > 1)
254      Ty = llvm::ArrayType::get(Ty, NumBytes);
255
256    llvm::Constant *C = llvm::Constant::getNullValue(Ty);
257    Elements.push_back(C);
258    assert(getAlignment(C) == 1 && "Padding must have 1 byte alignment!");
259
260    NextFieldOffsetInBytes += getSizeInBytes(C);
261  }
262
263  void AppendTailPadding(uint64_t RecordSize) {
264    assert(RecordSize % 8 == 0 && "Invalid record size!");
265
266    uint64_t RecordSizeInBytes = RecordSize / 8;
267    assert(NextFieldOffsetInBytes <= RecordSizeInBytes && "Size mismatch!");
268
269    unsigned NumPadBytes = RecordSizeInBytes - NextFieldOffsetInBytes;
270    AppendPadding(NumPadBytes);
271  }
272
273  bool Build(InitListExpr *ILE) {
274    RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl();
275    const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
276
277    unsigned FieldNo = 0;
278    unsigned ElementNo = 0;
279    for (RecordDecl::field_iterator Field = RD->field_begin(),
280         FieldEnd = RD->field_end();
281         ElementNo < ILE->getNumInits() && Field != FieldEnd;
282         ++Field, ++FieldNo) {
283      if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field)
284        continue;
285
286      if (Field->isBitField()) {
287        if (!Field->getIdentifier())
288          continue;
289
290        if (!AppendBitField(*Field, Layout.getFieldOffset(FieldNo),
291                            ILE->getInit(ElementNo)))
292          return false;
293      } else {
294        if (!AppendField(*Field, Layout.getFieldOffset(FieldNo),
295                         ILE->getInit(ElementNo)))
296          return false;
297      }
298
299      ElementNo++;
300    }
301
302    uint64_t LayoutSizeInBytes = Layout.getSize() / 8;
303
304    if (NextFieldOffsetInBytes > LayoutSizeInBytes) {
305      // If the struct is bigger than the size of the record type,
306      // we must have a flexible array member at the end.
307      assert(RD->hasFlexibleArrayMember() &&
308             "Must have flexible array member if struct is bigger than type!");
309
310      // No tail padding is necessary.
311      return true;
312    }
313
314    // Append tail padding if necessary.
315    AppendTailPadding(Layout.getSize());
316
317    assert(Layout.getSize() / 8 == NextFieldOffsetInBytes &&
318           "Tail padding mismatch!");
319
320    return true;
321  }
322
323  unsigned getAlignment(const llvm::Constant *C) const {
324    if (Packed)
325      return 1;
326
327    return CGM.getTargetData().getABITypeAlignment(C->getType());
328  }
329
330  uint64_t getSizeInBytes(const llvm::Constant *C) const {
331    return CGM.getTargetData().getTypeAllocSize(C->getType());
332  }
333
334public:
335  static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF,
336                                     InitListExpr *ILE) {
337    ConstStructBuilder Builder(CGM, CGF);
338
339    if (!Builder.Build(ILE))
340      return 0;
341
342    llvm::Constant *Result =
343      llvm::ConstantStruct::get(CGM.getLLVMContext(),
344                                Builder.Elements, Builder.Packed);
345
346    assert(llvm::RoundUpToAlignment(Builder.NextFieldOffsetInBytes,
347                                    Builder.getAlignment(Result)) ==
348           Builder.getSizeInBytes(Result) && "Size mismatch!");
349
350    return Result;
351  }
352};
353
354class VISIBILITY_HIDDEN ConstExprEmitter :
355  public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
356  CodeGenModule &CGM;
357  CodeGenFunction *CGF;
358  llvm::LLVMContext &VMContext;
359public:
360  ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf)
361    : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) {
362  }
363
364  //===--------------------------------------------------------------------===//
365  //                            Visitor Methods
366  //===--------------------------------------------------------------------===//
367
368  llvm::Constant *VisitStmt(Stmt *S) {
369    return 0;
370  }
371
372  llvm::Constant *VisitParenExpr(ParenExpr *PE) {
373    return Visit(PE->getSubExpr());
374  }
375
376  llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
377    return Visit(E->getInitializer());
378  }
379
380  llvm::Constant *VisitCastExpr(CastExpr* E) {
381    // GCC cast to union extension
382    if (E->getType()->isUnionType()) {
383      const llvm::Type *Ty = ConvertType(E->getType());
384      Expr *SubExpr = E->getSubExpr();
385
386      llvm::Constant *C =
387        CGM.EmitConstantExpr(SubExpr, SubExpr->getType(), CGF);
388      if (!C)
389        return 0;
390
391      // Build a struct with the union sub-element as the first member,
392      // and padded to the appropriate size
393      std::vector<llvm::Constant*> Elts;
394      std::vector<const llvm::Type*> Types;
395      Elts.push_back(C);
396      Types.push_back(C->getType());
397      unsigned CurSize = CGM.getTargetData().getTypeAllocSize(C->getType());
398      unsigned TotalSize = CGM.getTargetData().getTypeAllocSize(Ty);
399
400      assert(CurSize <= TotalSize && "Union size mismatch!");
401      if (unsigned NumPadBytes = TotalSize - CurSize) {
402        const llvm::Type *Ty = llvm::Type::getInt8Ty(VMContext);
403        if (NumPadBytes > 1)
404          Ty = llvm::ArrayType::get(Ty, NumPadBytes);
405
406        Elts.push_back(llvm::Constant::getNullValue(Ty));
407        Types.push_back(Ty);
408      }
409
410      llvm::StructType* STy = llvm::StructType::get(C->getType()->getContext(),
411                                                    Types, false);
412      return llvm::ConstantStruct::get(STy, Elts);
413    }
414
415    // Explicit and implicit no-op casts
416    QualType Ty = E->getType(), SubTy = E->getSubExpr()->getType();
417    if (CGM.getContext().hasSameUnqualifiedType(Ty, SubTy)) {
418      return Visit(E->getSubExpr());
419    }
420    return 0;
421  }
422
423  llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
424    return Visit(DAE->getExpr());
425  }
426
427  llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) {
428    std::vector<llvm::Constant*> Elts;
429    const llvm::ArrayType *AType =
430        cast<llvm::ArrayType>(ConvertType(ILE->getType()));
431    unsigned NumInitElements = ILE->getNumInits();
432    // FIXME: Check for wide strings
433    // FIXME: Check for NumInitElements exactly equal to 1??
434    if (NumInitElements > 0 &&
435        (isa<StringLiteral>(ILE->getInit(0)) ||
436         isa<ObjCEncodeExpr>(ILE->getInit(0))) &&
437        ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType())
438      return Visit(ILE->getInit(0));
439    const llvm::Type *ElemTy = AType->getElementType();
440    unsigned NumElements = AType->getNumElements();
441
442    // Initialising an array requires us to automatically
443    // initialise any elements that have not been initialised explicitly
444    unsigned NumInitableElts = std::min(NumInitElements, NumElements);
445
446    // Copy initializer elements.
447    unsigned i = 0;
448    bool RewriteType = false;
449    for (; i < NumInitableElts; ++i) {
450      Expr *Init = ILE->getInit(i);
451      llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF);
452      if (!C)
453        return 0;
454      RewriteType |= (C->getType() != ElemTy);
455      Elts.push_back(C);
456    }
457
458    // Initialize remaining array elements.
459    // FIXME: This doesn't handle member pointers correctly!
460    for (; i < NumElements; ++i)
461      Elts.push_back(llvm::Constant::getNullValue(ElemTy));
462
463    if (RewriteType) {
464      // FIXME: Try to avoid packing the array
465      std::vector<const llvm::Type*> Types;
466      for (unsigned i = 0; i < Elts.size(); ++i)
467        Types.push_back(Elts[i]->getType());
468      const llvm::StructType *SType = llvm::StructType::get(AType->getContext(),
469                                                            Types, true);
470      return llvm::ConstantStruct::get(SType, Elts);
471    }
472
473    return llvm::ConstantArray::get(AType, Elts);
474  }
475
476  llvm::Constant *EmitStructInitialization(InitListExpr *ILE) {
477    return ConstStructBuilder::BuildStruct(CGM, CGF, ILE);
478  }
479
480  llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) {
481    return ConstStructBuilder::BuildStruct(CGM, CGF, ILE);
482  }
483
484  llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) {
485    const llvm::VectorType *VType =
486        cast<llvm::VectorType>(ConvertType(ILE->getType()));
487    const llvm::Type *ElemTy = VType->getElementType();
488    std::vector<llvm::Constant*> Elts;
489    unsigned NumElements = VType->getNumElements();
490    unsigned NumInitElements = ILE->getNumInits();
491
492    unsigned NumInitableElts = std::min(NumInitElements, NumElements);
493
494    // Copy initializer elements.
495    unsigned i = 0;
496    for (; i < NumInitableElts; ++i) {
497      Expr *Init = ILE->getInit(i);
498      llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF);
499      if (!C)
500        return 0;
501      Elts.push_back(C);
502    }
503
504    for (; i < NumElements; ++i)
505      Elts.push_back(llvm::Constant::getNullValue(ElemTy));
506
507    return llvm::ConstantVector::get(VType, Elts);
508  }
509
510  llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) {
511    return CGM.EmitNullConstant(E->getType());
512  }
513
514  llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
515    if (ILE->getType()->isScalarType()) {
516      // We have a scalar in braces. Just use the first element.
517      if (ILE->getNumInits() > 0) {
518        Expr *Init = ILE->getInit(0);
519        return CGM.EmitConstantExpr(Init, Init->getType(), CGF);
520      }
521      return CGM.EmitNullConstant(ILE->getType());
522    }
523
524    if (ILE->getType()->isArrayType())
525      return EmitArrayInitialization(ILE);
526
527    if (ILE->getType()->isStructureType())
528      return EmitStructInitialization(ILE);
529
530    if (ILE->getType()->isUnionType())
531      return EmitUnionInitialization(ILE);
532
533    if (ILE->getType()->isVectorType())
534      return EmitVectorInitialization(ILE);
535
536    assert(0 && "Unable to handle InitListExpr");
537    // Get rid of control reaches end of void function warning.
538    // Not reached.
539    return 0;
540  }
541
542  llvm::Constant *VisitStringLiteral(StringLiteral *E) {
543    assert(!E->getType()->isPointerType() && "Strings are always arrays");
544
545    // This must be a string initializing an array in a static initializer.
546    // Don't emit it as the address of the string, emit the string data itself
547    // as an inline array.
548    return llvm::ConstantArray::get(VMContext,
549                                    CGM.GetStringForStringLiteral(E), false);
550  }
551
552  llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
553    // This must be an @encode initializing an array in a static initializer.
554    // Don't emit it as the address of the string, emit the string data itself
555    // as an inline array.
556    std::string Str;
557    CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str);
558    const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType());
559
560    // Resize the string to the right size, adding zeros at the end, or
561    // truncating as needed.
562    Str.resize(CAT->getSize().getZExtValue(), '\0');
563    return llvm::ConstantArray::get(VMContext, Str, false);
564  }
565
566  llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) {
567    return Visit(E->getSubExpr());
568  }
569
570  // Utility methods
571  const llvm::Type *ConvertType(QualType T) {
572    return CGM.getTypes().ConvertType(T);
573  }
574
575public:
576  llvm::Constant *EmitLValue(Expr *E) {
577    switch (E->getStmtClass()) {
578    default: break;
579    case Expr::CompoundLiteralExprClass: {
580      // Note that due to the nature of compound literals, this is guaranteed
581      // to be the only use of the variable, so we just generate it here.
582      CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
583      llvm::Constant* C = Visit(CLE->getInitializer());
584      // FIXME: "Leaked" on failure.
585      if (C)
586        C = new llvm::GlobalVariable(CGM.getModule(), C->getType(),
587                                     E->getType().isConstQualified(),
588                                     llvm::GlobalValue::InternalLinkage,
589                                     C, ".compoundliteral");
590      return C;
591    }
592    case Expr::DeclRefExprClass:
593    case Expr::QualifiedDeclRefExprClass: {
594      NamedDecl *Decl = cast<DeclRefExpr>(E)->getDecl();
595      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
596        return CGM.GetAddrOfFunction(GlobalDecl(FD));
597      if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) {
598        // We can never refer to a variable with local storage.
599        if (!VD->hasLocalStorage()) {
600          if (VD->isFileVarDecl() || VD->hasExternalStorage())
601            return CGM.GetAddrOfGlobalVar(VD);
602          else if (VD->isBlockVarDecl()) {
603            assert(CGF && "Can't access static local vars without CGF");
604            return CGF->GetAddrOfStaticLocalVar(VD);
605          }
606        }
607      }
608      break;
609    }
610    case Expr::StringLiteralClass:
611      return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E));
612    case Expr::ObjCEncodeExprClass:
613      return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E));
614    case Expr::ObjCStringLiteralClass: {
615      ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E);
616      llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(SL);
617      return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType()));
618    }
619    case Expr::PredefinedExprClass: {
620      // __func__/__FUNCTION__ -> "".  __PRETTY_FUNCTION__ -> "top level".
621      std::string Str;
622      if (cast<PredefinedExpr>(E)->getIdentType() ==
623          PredefinedExpr::PrettyFunction)
624        Str = "top level";
625
626      return CGM.GetAddrOfConstantCString(Str, ".tmp");
627    }
628    case Expr::AddrLabelExprClass: {
629      assert(CGF && "Invalid address of label expression outside function.");
630      unsigned id =
631          CGF->GetIDForAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel());
632      llvm::Constant *C =
633            llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), id);
634      return llvm::ConstantExpr::getIntToPtr(C, ConvertType(E->getType()));
635    }
636    case Expr::CallExprClass: {
637      CallExpr* CE = cast<CallExpr>(E);
638      if (CE->isBuiltinCall(CGM.getContext()) !=
639            Builtin::BI__builtin___CFStringMakeConstantString)
640        break;
641      const Expr *Arg = CE->getArg(0)->IgnoreParenCasts();
642      const StringLiteral *Literal = cast<StringLiteral>(Arg);
643      // FIXME: need to deal with UCN conversion issues.
644      return CGM.GetAddrOfConstantCFString(Literal);
645    }
646    case Expr::BlockExprClass: {
647      std::string FunctionName;
648      if (CGF)
649        FunctionName = CGF->CurFn->getName();
650      else
651        FunctionName = "global";
652
653      return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str());
654    }
655    }
656
657    return 0;
658  }
659};
660
661}  // end anonymous namespace.
662
663llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
664                                                QualType DestType,
665                                                CodeGenFunction *CGF) {
666  Expr::EvalResult Result;
667
668  bool Success = false;
669
670  if (DestType->isReferenceType())
671    Success = E->EvaluateAsLValue(Result, Context);
672  else
673    Success = E->Evaluate(Result, Context);
674
675  if (Success) {
676    assert(!Result.HasSideEffects &&
677           "Constant expr should not have any side effects!");
678    switch (Result.Val.getKind()) {
679    case APValue::Uninitialized:
680      assert(0 && "Constant expressions should be initialized.");
681      return 0;
682    case APValue::LValue: {
683      const llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType);
684      llvm::Constant *Offset =
685        llvm::ConstantInt::get(llvm::Type::getInt64Ty(VMContext),
686                               Result.Val.getLValueOffset());
687
688      llvm::Constant *C;
689      if (const Expr *LVBase = Result.Val.getLValueBase()) {
690        C = ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase));
691
692        // Apply offset if necessary.
693        if (!Offset->isNullValue()) {
694          const llvm::Type *Type =
695            llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext));
696          llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Type);
697          Casted = llvm::ConstantExpr::getGetElementPtr(Casted, &Offset, 1);
698          C = llvm::ConstantExpr::getBitCast(Casted, C->getType());
699        }
700
701        // Convert to the appropriate type; this could be an lvalue for
702        // an integer.
703        if (isa<llvm::PointerType>(DestTy))
704          return llvm::ConstantExpr::getBitCast(C, DestTy);
705
706        return llvm::ConstantExpr::getPtrToInt(C, DestTy);
707      } else {
708        C = Offset;
709
710        // Convert to the appropriate type; this could be an lvalue for
711        // an integer.
712        if (isa<llvm::PointerType>(DestTy))
713          return llvm::ConstantExpr::getIntToPtr(C, DestTy);
714
715        // If the types don't match this should only be a truncate.
716        if (C->getType() != DestTy)
717          return llvm::ConstantExpr::getTrunc(C, DestTy);
718
719        return C;
720      }
721    }
722    case APValue::Int: {
723      llvm::Constant *C = llvm::ConstantInt::get(VMContext,
724                                                 Result.Val.getInt());
725
726      if (C->getType() == llvm::Type::getInt1Ty(VMContext)) {
727        const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
728        C = llvm::ConstantExpr::getZExt(C, BoolTy);
729      }
730      return C;
731    }
732    case APValue::ComplexInt: {
733      llvm::Constant *Complex[2];
734
735      Complex[0] = llvm::ConstantInt::get(VMContext,
736                                          Result.Val.getComplexIntReal());
737      Complex[1] = llvm::ConstantInt::get(VMContext,
738                                          Result.Val.getComplexIntImag());
739
740      return llvm::ConstantStruct::get(VMContext, Complex, 2);
741    }
742    case APValue::Float:
743      return llvm::ConstantFP::get(VMContext, Result.Val.getFloat());
744    case APValue::ComplexFloat: {
745      llvm::Constant *Complex[2];
746
747      Complex[0] = llvm::ConstantFP::get(VMContext,
748                                         Result.Val.getComplexFloatReal());
749      Complex[1] = llvm::ConstantFP::get(VMContext,
750                                         Result.Val.getComplexFloatImag());
751
752      return llvm::ConstantStruct::get(VMContext, Complex, 2);
753    }
754    case APValue::Vector: {
755      llvm::SmallVector<llvm::Constant *, 4> Inits;
756      unsigned NumElts = Result.Val.getVectorLength();
757
758      for (unsigned i = 0; i != NumElts; ++i) {
759        APValue &Elt = Result.Val.getVectorElt(i);
760        if (Elt.isInt())
761          Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt()));
762        else
763          Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat()));
764      }
765      return llvm::ConstantVector::get(&Inits[0], Inits.size());
766    }
767    }
768  }
769
770  llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
771  if (C && C->getType() == llvm::Type::getInt1Ty(VMContext)) {
772    const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
773    C = llvm::ConstantExpr::getZExt(C, BoolTy);
774  }
775  return C;
776}
777
778llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) {
779  if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) {
780
781    QualType ElementTy = CAT->getElementType();
782
783    // FIXME: Handle arrays of structs that contain member pointers.
784    if (Context.getBaseElementType(ElementTy)->isMemberPointerType()) {
785      llvm::Constant *Element = EmitNullConstant(ElementTy);
786      uint64_t NumElements = CAT->getSize().getZExtValue();
787      std::vector<llvm::Constant *> Array(NumElements);
788      for (uint64_t i = 0; i != NumElements; ++i)
789        Array[i] = Element;
790
791      const llvm::ArrayType *ATy =
792        cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T));
793      return llvm::ConstantArray::get(ATy, Array);
794    }
795  }
796
797  // FIXME: Handle structs that contain member pointers.
798  if (T->isMemberPointerType())
799    return llvm::Constant::getAllOnesValue(getTypes().ConvertTypeForMem(T));
800
801  return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T));
802}
803