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 "CGCXXABI.h"
17#include "CGObjCRuntime.h"
18#include "CGRecordLayout.h"
19#include "clang/AST/APValue.h"
20#include "clang/AST/ASTContext.h"
21#include "clang/AST/RecordLayout.h"
22#include "clang/AST/StmtVisitor.h"
23#include "clang/Basic/Builtins.h"
24#include "llvm/Constants.h"
25#include "llvm/Function.h"
26#include "llvm/GlobalVariable.h"
27#include "llvm/Target/TargetData.h"
28using namespace clang;
29using namespace CodeGen;
30
31//===----------------------------------------------------------------------===//
32//                            ConstStructBuilder
33//===----------------------------------------------------------------------===//
34
35namespace {
36class ConstStructBuilder {
37  CodeGenModule &CGM;
38  CodeGenFunction *CGF;
39
40  bool Packed;
41  CharUnits NextFieldOffsetInChars;
42  CharUnits LLVMStructAlignment;
43  SmallVector<llvm::Constant *, 32> Elements;
44public:
45  static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF,
46                                     InitListExpr *ILE);
47  static llvm::Constant *BuildStruct(CodeGenModule &CGM, CodeGenFunction *CGF,
48                                     const APValue &Value, QualType ValTy);
49
50private:
51  ConstStructBuilder(CodeGenModule &CGM, CodeGenFunction *CGF)
52    : CGM(CGM), CGF(CGF), Packed(false),
53    NextFieldOffsetInChars(CharUnits::Zero()),
54    LLVMStructAlignment(CharUnits::One()) { }
55
56  void AppendVTablePointer(BaseSubobject Base, llvm::Constant *VTable,
57                           const CXXRecordDecl *VTableClass);
58
59  void AppendField(const FieldDecl *Field, uint64_t FieldOffset,
60                   llvm::Constant *InitExpr);
61
62  void AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst);
63
64  void AppendBitField(const FieldDecl *Field, uint64_t FieldOffset,
65                      llvm::ConstantInt *InitExpr);
66
67  void AppendPadding(CharUnits PadSize);
68
69  void AppendTailPadding(CharUnits RecordSize);
70
71  void ConvertStructToPacked();
72
73  bool Build(InitListExpr *ILE);
74  void Build(const APValue &Val, const RecordDecl *RD, bool IsPrimaryBase,
75             llvm::Constant *VTable, const CXXRecordDecl *VTableClass,
76             CharUnits BaseOffset);
77  llvm::Constant *Finalize(QualType Ty);
78
79  CharUnits getAlignment(const llvm::Constant *C) const {
80    if (Packed)  return CharUnits::One();
81    return CharUnits::fromQuantity(
82        CGM.getTargetData().getABITypeAlignment(C->getType()));
83  }
84
85  CharUnits getSizeInChars(const llvm::Constant *C) const {
86    return CharUnits::fromQuantity(
87        CGM.getTargetData().getTypeAllocSize(C->getType()));
88  }
89};
90
91void ConstStructBuilder::AppendVTablePointer(BaseSubobject Base,
92                                             llvm::Constant *VTable,
93                                             const CXXRecordDecl *VTableClass) {
94  // Find the appropriate vtable within the vtable group.
95  uint64_t AddressPoint =
96    CGM.getVTableContext().getVTableLayout(VTableClass).getAddressPoint(Base);
97  llvm::Value *Indices[] = {
98    llvm::ConstantInt::get(CGM.Int64Ty, 0),
99    llvm::ConstantInt::get(CGM.Int64Ty, AddressPoint)
100  };
101  llvm::Constant *VTableAddressPoint =
102    llvm::ConstantExpr::getInBoundsGetElementPtr(VTable, Indices);
103
104  // Add the vtable at the start of the object.
105  AppendBytes(Base.getBaseOffset(), VTableAddressPoint);
106}
107
108void ConstStructBuilder::
109AppendField(const FieldDecl *Field, uint64_t FieldOffset,
110            llvm::Constant *InitCst) {
111  const ASTContext &Context = CGM.getContext();
112
113  CharUnits FieldOffsetInChars = Context.toCharUnitsFromBits(FieldOffset);
114
115  AppendBytes(FieldOffsetInChars, InitCst);
116}
117
118void ConstStructBuilder::
119AppendBytes(CharUnits FieldOffsetInChars, llvm::Constant *InitCst) {
120
121  assert(NextFieldOffsetInChars <= FieldOffsetInChars
122         && "Field offset mismatch!");
123
124  CharUnits FieldAlignment = getAlignment(InitCst);
125
126  // Round up the field offset to the alignment of the field type.
127  CharUnits AlignedNextFieldOffsetInChars =
128    NextFieldOffsetInChars.RoundUpToAlignment(FieldAlignment);
129
130  if (AlignedNextFieldOffsetInChars > FieldOffsetInChars) {
131    assert(!Packed && "Alignment is wrong even with a packed struct!");
132
133    // Convert the struct to a packed struct.
134    ConvertStructToPacked();
135
136    AlignedNextFieldOffsetInChars = NextFieldOffsetInChars;
137  }
138
139  if (AlignedNextFieldOffsetInChars < FieldOffsetInChars) {
140    // We need to append padding.
141    AppendPadding(FieldOffsetInChars - NextFieldOffsetInChars);
142
143    assert(NextFieldOffsetInChars == FieldOffsetInChars &&
144           "Did not add enough padding!");
145
146    AlignedNextFieldOffsetInChars = NextFieldOffsetInChars;
147  }
148
149  // Add the field.
150  Elements.push_back(InitCst);
151  NextFieldOffsetInChars = AlignedNextFieldOffsetInChars +
152                           getSizeInChars(InitCst);
153
154  if (Packed)
155    assert(LLVMStructAlignment == CharUnits::One() &&
156           "Packed struct not byte-aligned!");
157  else
158    LLVMStructAlignment = std::max(LLVMStructAlignment, FieldAlignment);
159}
160
161void ConstStructBuilder::AppendBitField(const FieldDecl *Field,
162                                        uint64_t FieldOffset,
163                                        llvm::ConstantInt *CI) {
164  const ASTContext &Context = CGM.getContext();
165  const uint64_t CharWidth = Context.getCharWidth();
166  uint64_t NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars);
167  if (FieldOffset > NextFieldOffsetInBits) {
168    // We need to add padding.
169    CharUnits PadSize = Context.toCharUnitsFromBits(
170      llvm::RoundUpToAlignment(FieldOffset - NextFieldOffsetInBits,
171                               Context.getTargetInfo().getCharAlign()));
172
173    AppendPadding(PadSize);
174  }
175
176  uint64_t FieldSize = Field->getBitWidthValue(Context);
177
178  llvm::APInt FieldValue = CI->getValue();
179
180  // Promote the size of FieldValue if necessary
181  // FIXME: This should never occur, but currently it can because initializer
182  // constants are cast to bool, and because clang is not enforcing bitfield
183  // width limits.
184  if (FieldSize > FieldValue.getBitWidth())
185    FieldValue = FieldValue.zext(FieldSize);
186
187  // Truncate the size of FieldValue to the bit field size.
188  if (FieldSize < FieldValue.getBitWidth())
189    FieldValue = FieldValue.trunc(FieldSize);
190
191  NextFieldOffsetInBits = Context.toBits(NextFieldOffsetInChars);
192  if (FieldOffset < NextFieldOffsetInBits) {
193    // Either part of the field or the entire field can go into the previous
194    // byte.
195    assert(!Elements.empty() && "Elements can't be empty!");
196
197    unsigned BitsInPreviousByte = NextFieldOffsetInBits - FieldOffset;
198
199    bool FitsCompletelyInPreviousByte =
200      BitsInPreviousByte >= FieldValue.getBitWidth();
201
202    llvm::APInt Tmp = FieldValue;
203
204    if (!FitsCompletelyInPreviousByte) {
205      unsigned NewFieldWidth = FieldSize - BitsInPreviousByte;
206
207      if (CGM.getTargetData().isBigEndian()) {
208        Tmp = Tmp.lshr(NewFieldWidth);
209        Tmp = Tmp.trunc(BitsInPreviousByte);
210
211        // We want the remaining high bits.
212        FieldValue = FieldValue.trunc(NewFieldWidth);
213      } else {
214        Tmp = Tmp.trunc(BitsInPreviousByte);
215
216        // We want the remaining low bits.
217        FieldValue = FieldValue.lshr(BitsInPreviousByte);
218        FieldValue = FieldValue.trunc(NewFieldWidth);
219      }
220    }
221
222    Tmp = Tmp.zext(CharWidth);
223    if (CGM.getTargetData().isBigEndian()) {
224      if (FitsCompletelyInPreviousByte)
225        Tmp = Tmp.shl(BitsInPreviousByte - FieldValue.getBitWidth());
226    } else {
227      Tmp = Tmp.shl(CharWidth - BitsInPreviousByte);
228    }
229
230    // 'or' in the bits that go into the previous byte.
231    llvm::Value *LastElt = Elements.back();
232    if (llvm::ConstantInt *Val = dyn_cast<llvm::ConstantInt>(LastElt))
233      Tmp |= Val->getValue();
234    else {
235      assert(isa<llvm::UndefValue>(LastElt));
236      // If there is an undef field that we're adding to, it can either be a
237      // scalar undef (in which case, we just replace it with our field) or it
238      // is an array.  If it is an array, we have to pull one byte off the
239      // array so that the other undef bytes stay around.
240      if (!isa<llvm::IntegerType>(LastElt->getType())) {
241        // The undef padding will be a multibyte array, create a new smaller
242        // padding and then an hole for our i8 to get plopped into.
243        assert(isa<llvm::ArrayType>(LastElt->getType()) &&
244               "Expected array padding of undefs");
245        llvm::ArrayType *AT = cast<llvm::ArrayType>(LastElt->getType());
246        assert(AT->getElementType()->isIntegerTy(CharWidth) &&
247               AT->getNumElements() != 0 &&
248               "Expected non-empty array padding of undefs");
249
250        // Remove the padding array.
251        NextFieldOffsetInChars -= CharUnits::fromQuantity(AT->getNumElements());
252        Elements.pop_back();
253
254        // Add the padding back in two chunks.
255        AppendPadding(CharUnits::fromQuantity(AT->getNumElements()-1));
256        AppendPadding(CharUnits::One());
257        assert(isa<llvm::UndefValue>(Elements.back()) &&
258               Elements.back()->getType()->isIntegerTy(CharWidth) &&
259               "Padding addition didn't work right");
260      }
261    }
262
263    Elements.back() = llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp);
264
265    if (FitsCompletelyInPreviousByte)
266      return;
267  }
268
269  while (FieldValue.getBitWidth() > CharWidth) {
270    llvm::APInt Tmp;
271
272    if (CGM.getTargetData().isBigEndian()) {
273      // We want the high bits.
274      Tmp =
275        FieldValue.lshr(FieldValue.getBitWidth() - CharWidth).trunc(CharWidth);
276    } else {
277      // We want the low bits.
278      Tmp = FieldValue.trunc(CharWidth);
279
280      FieldValue = FieldValue.lshr(CharWidth);
281    }
282
283    Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(), Tmp));
284    ++NextFieldOffsetInChars;
285
286    FieldValue = FieldValue.trunc(FieldValue.getBitWidth() - CharWidth);
287  }
288
289  assert(FieldValue.getBitWidth() > 0 &&
290         "Should have at least one bit left!");
291  assert(FieldValue.getBitWidth() <= CharWidth &&
292         "Should not have more than a byte left!");
293
294  if (FieldValue.getBitWidth() < CharWidth) {
295    if (CGM.getTargetData().isBigEndian()) {
296      unsigned BitWidth = FieldValue.getBitWidth();
297
298      FieldValue = FieldValue.zext(CharWidth) << (CharWidth - BitWidth);
299    } else
300      FieldValue = FieldValue.zext(CharWidth);
301  }
302
303  // Append the last element.
304  Elements.push_back(llvm::ConstantInt::get(CGM.getLLVMContext(),
305                                            FieldValue));
306  ++NextFieldOffsetInChars;
307}
308
309void ConstStructBuilder::AppendPadding(CharUnits PadSize) {
310  if (PadSize.isZero())
311    return;
312
313  llvm::Type *Ty = CGM.Int8Ty;
314  if (PadSize > CharUnits::One())
315    Ty = llvm::ArrayType::get(Ty, PadSize.getQuantity());
316
317  llvm::Constant *C = llvm::UndefValue::get(Ty);
318  Elements.push_back(C);
319  assert(getAlignment(C) == CharUnits::One() &&
320         "Padding must have 1 byte alignment!");
321
322  NextFieldOffsetInChars += getSizeInChars(C);
323}
324
325void ConstStructBuilder::AppendTailPadding(CharUnits RecordSize) {
326  assert(NextFieldOffsetInChars <= RecordSize &&
327         "Size mismatch!");
328
329  AppendPadding(RecordSize - NextFieldOffsetInChars);
330}
331
332void ConstStructBuilder::ConvertStructToPacked() {
333  SmallVector<llvm::Constant *, 16> PackedElements;
334  CharUnits ElementOffsetInChars = CharUnits::Zero();
335
336  for (unsigned i = 0, e = Elements.size(); i != e; ++i) {
337    llvm::Constant *C = Elements[i];
338
339    CharUnits ElementAlign = CharUnits::fromQuantity(
340      CGM.getTargetData().getABITypeAlignment(C->getType()));
341    CharUnits AlignedElementOffsetInChars =
342      ElementOffsetInChars.RoundUpToAlignment(ElementAlign);
343
344    if (AlignedElementOffsetInChars > ElementOffsetInChars) {
345      // We need some padding.
346      CharUnits NumChars =
347        AlignedElementOffsetInChars - ElementOffsetInChars;
348
349      llvm::Type *Ty = CGM.Int8Ty;
350      if (NumChars > CharUnits::One())
351        Ty = llvm::ArrayType::get(Ty, NumChars.getQuantity());
352
353      llvm::Constant *Padding = llvm::UndefValue::get(Ty);
354      PackedElements.push_back(Padding);
355      ElementOffsetInChars += getSizeInChars(Padding);
356    }
357
358    PackedElements.push_back(C);
359    ElementOffsetInChars += getSizeInChars(C);
360  }
361
362  assert(ElementOffsetInChars == NextFieldOffsetInChars &&
363         "Packing the struct changed its size!");
364
365  Elements.swap(PackedElements);
366  LLVMStructAlignment = CharUnits::One();
367  Packed = true;
368}
369
370bool ConstStructBuilder::Build(InitListExpr *ILE) {
371  if (ILE->initializesStdInitializerList()) {
372    //CGM.ErrorUnsupported(ILE, "global std::initializer_list");
373    return false;
374  }
375
376  RecordDecl *RD = ILE->getType()->getAs<RecordType>()->getDecl();
377  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
378
379  unsigned FieldNo = 0;
380  unsigned ElementNo = 0;
381  const FieldDecl *LastFD = 0;
382  bool IsMsStruct = RD->hasAttr<MsStructAttr>();
383
384  for (RecordDecl::field_iterator Field = RD->field_begin(),
385       FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
386    if (IsMsStruct) {
387      // Zero-length bitfields following non-bitfield members are
388      // ignored:
389      if (CGM.getContext().ZeroBitfieldFollowsNonBitfield(*Field, LastFD)) {
390        --FieldNo;
391        continue;
392      }
393      LastFD = *Field;
394    }
395
396    // If this is a union, skip all the fields that aren't being initialized.
397    if (RD->isUnion() && ILE->getInitializedFieldInUnion() != *Field)
398      continue;
399
400    // Don't emit anonymous bitfields, they just affect layout.
401    if (Field->isUnnamedBitfield()) {
402      LastFD = *Field;
403      continue;
404    }
405
406    // Get the initializer.  A struct can include fields without initializers,
407    // we just use explicit null values for them.
408    llvm::Constant *EltInit;
409    if (ElementNo < ILE->getNumInits())
410      EltInit = CGM.EmitConstantExpr(ILE->getInit(ElementNo++),
411                                     Field->getType(), CGF);
412    else
413      EltInit = CGM.EmitNullConstant(Field->getType());
414
415    if (!EltInit)
416      return false;
417
418    if (!Field->isBitField()) {
419      // Handle non-bitfield members.
420      AppendField(*Field, Layout.getFieldOffset(FieldNo), EltInit);
421    } else {
422      // Otherwise we have a bitfield.
423      AppendBitField(*Field, Layout.getFieldOffset(FieldNo),
424                     cast<llvm::ConstantInt>(EltInit));
425    }
426  }
427
428  return true;
429}
430
431namespace {
432struct BaseInfo {
433  BaseInfo(const CXXRecordDecl *Decl, CharUnits Offset, unsigned Index)
434    : Decl(Decl), Offset(Offset), Index(Index) {
435  }
436
437  const CXXRecordDecl *Decl;
438  CharUnits Offset;
439  unsigned Index;
440
441  bool operator<(const BaseInfo &O) const { return Offset < O.Offset; }
442};
443}
444
445void ConstStructBuilder::Build(const APValue &Val, const RecordDecl *RD,
446                               bool IsPrimaryBase, llvm::Constant *VTable,
447                               const CXXRecordDecl *VTableClass,
448                               CharUnits Offset) {
449  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
450
451  if (const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD)) {
452    // Add a vtable pointer, if we need one and it hasn't already been added.
453    if (CD->isDynamicClass() && !IsPrimaryBase)
454      AppendVTablePointer(BaseSubobject(CD, Offset), VTable, VTableClass);
455
456    // Accumulate and sort bases, in order to visit them in address order, which
457    // may not be the same as declaration order.
458    llvm::SmallVector<BaseInfo, 8> Bases;
459    Bases.reserve(CD->getNumBases());
460    unsigned BaseNo = 0;
461    for (CXXRecordDecl::base_class_const_iterator Base = CD->bases_begin(),
462         BaseEnd = CD->bases_end(); Base != BaseEnd; ++Base, ++BaseNo) {
463      assert(!Base->isVirtual() && "should not have virtual bases here");
464      const CXXRecordDecl *BD = Base->getType()->getAsCXXRecordDecl();
465      CharUnits BaseOffset = Layout.getBaseClassOffset(BD);
466      Bases.push_back(BaseInfo(BD, BaseOffset, BaseNo));
467    }
468    std::stable_sort(Bases.begin(), Bases.end());
469
470    for (unsigned I = 0, N = Bases.size(); I != N; ++I) {
471      BaseInfo &Base = Bases[I];
472
473      bool IsPrimaryBase = Layout.getPrimaryBase() == Base.Decl;
474      Build(Val.getStructBase(Base.Index), Base.Decl, IsPrimaryBase,
475            VTable, VTableClass, Offset + Base.Offset);
476    }
477  }
478
479  unsigned FieldNo = 0;
480  const FieldDecl *LastFD = 0;
481  bool IsMsStruct = RD->hasAttr<MsStructAttr>();
482  uint64_t OffsetBits = CGM.getContext().toBits(Offset);
483
484  for (RecordDecl::field_iterator Field = RD->field_begin(),
485       FieldEnd = RD->field_end(); Field != FieldEnd; ++Field, ++FieldNo) {
486    if (IsMsStruct) {
487      // Zero-length bitfields following non-bitfield members are
488      // ignored:
489      if (CGM.getContext().ZeroBitfieldFollowsNonBitfield(*Field, LastFD)) {
490        --FieldNo;
491        continue;
492      }
493      LastFD = *Field;
494    }
495
496    // If this is a union, skip all the fields that aren't being initialized.
497    if (RD->isUnion() && Val.getUnionField() != *Field)
498      continue;
499
500    // Don't emit anonymous bitfields, they just affect layout.
501    if (Field->isUnnamedBitfield()) {
502      LastFD = *Field;
503      continue;
504    }
505
506    // Emit the value of the initializer.
507    const APValue &FieldValue =
508      RD->isUnion() ? Val.getUnionValue() : Val.getStructField(FieldNo);
509    llvm::Constant *EltInit =
510      CGM.EmitConstantValueForMemory(FieldValue, Field->getType(), CGF);
511    assert(EltInit && "EmitConstantValue can't fail");
512
513    if (!Field->isBitField()) {
514      // Handle non-bitfield members.
515      AppendField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits, EltInit);
516    } else {
517      // Otherwise we have a bitfield.
518      AppendBitField(*Field, Layout.getFieldOffset(FieldNo) + OffsetBits,
519                     cast<llvm::ConstantInt>(EltInit));
520    }
521  }
522}
523
524llvm::Constant *ConstStructBuilder::Finalize(QualType Ty) {
525  RecordDecl *RD = Ty->getAs<RecordType>()->getDecl();
526  const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
527
528  CharUnits LayoutSizeInChars = Layout.getSize();
529
530  if (NextFieldOffsetInChars > LayoutSizeInChars) {
531    // If the struct is bigger than the size of the record type,
532    // we must have a flexible array member at the end.
533    assert(RD->hasFlexibleArrayMember() &&
534           "Must have flexible array member if struct is bigger than type!");
535
536    // No tail padding is necessary.
537  } else {
538    // Append tail padding if necessary.
539    AppendTailPadding(LayoutSizeInChars);
540
541    CharUnits LLVMSizeInChars =
542      NextFieldOffsetInChars.RoundUpToAlignment(LLVMStructAlignment);
543
544    // Check if we need to convert the struct to a packed struct.
545    if (NextFieldOffsetInChars <= LayoutSizeInChars &&
546        LLVMSizeInChars > LayoutSizeInChars) {
547      assert(!Packed && "Size mismatch!");
548
549      ConvertStructToPacked();
550      assert(NextFieldOffsetInChars <= LayoutSizeInChars &&
551             "Converting to packed did not help!");
552    }
553
554    assert(LayoutSizeInChars == NextFieldOffsetInChars &&
555           "Tail padding mismatch!");
556  }
557
558  // Pick the type to use.  If the type is layout identical to the ConvertType
559  // type then use it, otherwise use whatever the builder produced for us.
560  llvm::StructType *STy =
561      llvm::ConstantStruct::getTypeForElements(CGM.getLLVMContext(),
562                                               Elements, Packed);
563  llvm::Type *ValTy = CGM.getTypes().ConvertType(Ty);
564  if (llvm::StructType *ValSTy = dyn_cast<llvm::StructType>(ValTy)) {
565    if (ValSTy->isLayoutIdentical(STy))
566      STy = ValSTy;
567  }
568
569  llvm::Constant *Result = llvm::ConstantStruct::get(STy, Elements);
570
571  assert(NextFieldOffsetInChars.RoundUpToAlignment(getAlignment(Result)) ==
572         getSizeInChars(Result) && "Size mismatch!");
573
574  return Result;
575}
576
577llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM,
578                                                CodeGenFunction *CGF,
579                                                InitListExpr *ILE) {
580  ConstStructBuilder Builder(CGM, CGF);
581
582  if (!Builder.Build(ILE))
583    return 0;
584
585  return Builder.Finalize(ILE->getType());
586}
587
588llvm::Constant *ConstStructBuilder::BuildStruct(CodeGenModule &CGM,
589                                                CodeGenFunction *CGF,
590                                                const APValue &Val,
591                                                QualType ValTy) {
592  ConstStructBuilder Builder(CGM, CGF);
593
594  const RecordDecl *RD = ValTy->castAs<RecordType>()->getDecl();
595  const CXXRecordDecl *CD = dyn_cast<CXXRecordDecl>(RD);
596  llvm::Constant *VTable = 0;
597  if (CD && CD->isDynamicClass())
598    VTable = CGM.getVTables().GetAddrOfVTable(CD);
599
600  Builder.Build(Val, RD, false, VTable, CD, CharUnits::Zero());
601
602  return Builder.Finalize(ValTy);
603}
604
605
606//===----------------------------------------------------------------------===//
607//                             ConstExprEmitter
608//===----------------------------------------------------------------------===//
609
610/// This class only needs to handle two cases:
611/// 1) Literals (this is used by APValue emission to emit literals).
612/// 2) Arrays, structs and unions (outside C++11 mode, we don't currently
613///    constant fold these types).
614class ConstExprEmitter :
615  public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
616  CodeGenModule &CGM;
617  CodeGenFunction *CGF;
618  llvm::LLVMContext &VMContext;
619public:
620  ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf)
621    : CGM(cgm), CGF(cgf), VMContext(cgm.getLLVMContext()) {
622  }
623
624  //===--------------------------------------------------------------------===//
625  //                            Visitor Methods
626  //===--------------------------------------------------------------------===//
627
628  llvm::Constant *VisitStmt(Stmt *S) {
629    return 0;
630  }
631
632  llvm::Constant *VisitParenExpr(ParenExpr *PE) {
633    return Visit(PE->getSubExpr());
634  }
635
636  llvm::Constant *
637  VisitSubstNonTypeTemplateParmExpr(SubstNonTypeTemplateParmExpr *PE) {
638    return Visit(PE->getReplacement());
639  }
640
641  llvm::Constant *VisitGenericSelectionExpr(GenericSelectionExpr *GE) {
642    return Visit(GE->getResultExpr());
643  }
644
645  llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
646    return Visit(E->getInitializer());
647  }
648
649  llvm::Constant *VisitCastExpr(CastExpr* E) {
650    Expr *subExpr = E->getSubExpr();
651    llvm::Constant *C = CGM.EmitConstantExpr(subExpr, subExpr->getType(), CGF);
652    if (!C) return 0;
653
654    llvm::Type *destType = ConvertType(E->getType());
655
656    switch (E->getCastKind()) {
657    case CK_ToUnion: {
658      // GCC cast to union extension
659      assert(E->getType()->isUnionType() &&
660             "Destination type is not union type!");
661
662      // Build a struct with the union sub-element as the first member,
663      // and padded to the appropriate size
664      SmallVector<llvm::Constant*, 2> Elts;
665      SmallVector<llvm::Type*, 2> Types;
666      Elts.push_back(C);
667      Types.push_back(C->getType());
668      unsigned CurSize = CGM.getTargetData().getTypeAllocSize(C->getType());
669      unsigned TotalSize = CGM.getTargetData().getTypeAllocSize(destType);
670
671      assert(CurSize <= TotalSize && "Union size mismatch!");
672      if (unsigned NumPadBytes = TotalSize - CurSize) {
673        llvm::Type *Ty = CGM.Int8Ty;
674        if (NumPadBytes > 1)
675          Ty = llvm::ArrayType::get(Ty, NumPadBytes);
676
677        Elts.push_back(llvm::UndefValue::get(Ty));
678        Types.push_back(Ty);
679      }
680
681      llvm::StructType* STy =
682        llvm::StructType::get(C->getType()->getContext(), Types, false);
683      return llvm::ConstantStruct::get(STy, Elts);
684    }
685
686    case CK_LValueToRValue:
687    case CK_AtomicToNonAtomic:
688    case CK_NonAtomicToAtomic:
689    case CK_NoOp:
690      return C;
691
692    case CK_Dependent: llvm_unreachable("saw dependent cast!");
693
694    case CK_BuiltinFnToFnPtr:
695      llvm_unreachable("builtin functions are handled elsewhere");
696
697    case CK_ReinterpretMemberPointer:
698    case CK_DerivedToBaseMemberPointer:
699    case CK_BaseToDerivedMemberPointer:
700      return CGM.getCXXABI().EmitMemberPointerConversion(E, C);
701
702    // These will never be supported.
703    case CK_ObjCObjectLValueCast:
704    case CK_ARCProduceObject:
705    case CK_ARCConsumeObject:
706    case CK_ARCReclaimReturnedObject:
707    case CK_ARCExtendBlockObject:
708    case CK_CopyAndAutoreleaseBlockObject:
709      return 0;
710
711    // These don't need to be handled here because Evaluate knows how to
712    // evaluate them in the cases where they can be folded.
713    case CK_BitCast:
714    case CK_ToVoid:
715    case CK_Dynamic:
716    case CK_LValueBitCast:
717    case CK_NullToMemberPointer:
718    case CK_UserDefinedConversion:
719    case CK_ConstructorConversion:
720    case CK_CPointerToObjCPointerCast:
721    case CK_BlockPointerToObjCPointerCast:
722    case CK_AnyPointerToBlockPointerCast:
723    case CK_ArrayToPointerDecay:
724    case CK_FunctionToPointerDecay:
725    case CK_BaseToDerived:
726    case CK_DerivedToBase:
727    case CK_UncheckedDerivedToBase:
728    case CK_MemberPointerToBoolean:
729    case CK_VectorSplat:
730    case CK_FloatingRealToComplex:
731    case CK_FloatingComplexToReal:
732    case CK_FloatingComplexToBoolean:
733    case CK_FloatingComplexCast:
734    case CK_FloatingComplexToIntegralComplex:
735    case CK_IntegralRealToComplex:
736    case CK_IntegralComplexToReal:
737    case CK_IntegralComplexToBoolean:
738    case CK_IntegralComplexCast:
739    case CK_IntegralComplexToFloatingComplex:
740    case CK_PointerToIntegral:
741    case CK_PointerToBoolean:
742    case CK_NullToPointer:
743    case CK_IntegralCast:
744    case CK_IntegralToPointer:
745    case CK_IntegralToBoolean:
746    case CK_IntegralToFloating:
747    case CK_FloatingToIntegral:
748    case CK_FloatingToBoolean:
749    case CK_FloatingCast:
750      return 0;
751    }
752    llvm_unreachable("Invalid CastKind");
753  }
754
755  llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
756    return Visit(DAE->getExpr());
757  }
758
759  llvm::Constant *VisitMaterializeTemporaryExpr(MaterializeTemporaryExpr *E) {
760    return Visit(E->GetTemporaryExpr());
761  }
762
763  llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) {
764    if (ILE->isStringLiteralInit())
765      return Visit(ILE->getInit(0));
766
767    llvm::ArrayType *AType =
768        cast<llvm::ArrayType>(ConvertType(ILE->getType()));
769    llvm::Type *ElemTy = AType->getElementType();
770    unsigned NumInitElements = ILE->getNumInits();
771    unsigned NumElements = AType->getNumElements();
772
773    // Initialising an array requires us to automatically
774    // initialise any elements that have not been initialised explicitly
775    unsigned NumInitableElts = std::min(NumInitElements, NumElements);
776
777    // Copy initializer elements.
778    std::vector<llvm::Constant*> Elts;
779    Elts.reserve(NumInitableElts + NumElements);
780
781    bool RewriteType = false;
782    for (unsigned i = 0; i < NumInitableElts; ++i) {
783      Expr *Init = ILE->getInit(i);
784      llvm::Constant *C = CGM.EmitConstantExpr(Init, Init->getType(), CGF);
785      if (!C)
786        return 0;
787      RewriteType |= (C->getType() != ElemTy);
788      Elts.push_back(C);
789    }
790
791    // Initialize remaining array elements.
792    // FIXME: This doesn't handle member pointers correctly!
793    llvm::Constant *fillC;
794    if (Expr *filler = ILE->getArrayFiller())
795      fillC = CGM.EmitConstantExpr(filler, filler->getType(), CGF);
796    else
797      fillC = llvm::Constant::getNullValue(ElemTy);
798    if (!fillC)
799      return 0;
800    RewriteType |= (fillC->getType() != ElemTy);
801    Elts.resize(NumElements, fillC);
802
803    if (RewriteType) {
804      // FIXME: Try to avoid packing the array
805      std::vector<llvm::Type*> Types;
806      Types.reserve(NumInitableElts + NumElements);
807      for (unsigned i = 0, e = Elts.size(); i < e; ++i)
808        Types.push_back(Elts[i]->getType());
809      llvm::StructType *SType = llvm::StructType::get(AType->getContext(),
810                                                            Types, true);
811      return llvm::ConstantStruct::get(SType, Elts);
812    }
813
814    return llvm::ConstantArray::get(AType, Elts);
815  }
816
817  llvm::Constant *EmitStructInitialization(InitListExpr *ILE) {
818    return ConstStructBuilder::BuildStruct(CGM, CGF, ILE);
819  }
820
821  llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) {
822    return ConstStructBuilder::BuildStruct(CGM, CGF, ILE);
823  }
824
825  llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) {
826    return CGM.EmitNullConstant(E->getType());
827  }
828
829  llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
830    if (ILE->getType()->isArrayType())
831      return EmitArrayInitialization(ILE);
832
833    if (ILE->getType()->isUnionType())
834      return EmitUnionInitialization(ILE);
835
836    if (ILE->getType()->isRecordType())
837      return EmitStructInitialization(ILE);
838
839    return 0;
840  }
841
842  llvm::Constant *VisitCXXConstructExpr(CXXConstructExpr *E) {
843    if (!E->getConstructor()->isTrivial())
844      return 0;
845
846    QualType Ty = E->getType();
847
848    // FIXME: We should not have to call getBaseElementType here.
849    const RecordType *RT =
850      CGM.getContext().getBaseElementType(Ty)->getAs<RecordType>();
851    const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
852
853    // If the class doesn't have a trivial destructor, we can't emit it as a
854    // constant expr.
855    if (!RD->hasTrivialDestructor())
856      return 0;
857
858    // Only copy and default constructors can be trivial.
859
860
861    if (E->getNumArgs()) {
862      assert(E->getNumArgs() == 1 && "trivial ctor with > 1 argument");
863      assert(E->getConstructor()->isCopyOrMoveConstructor() &&
864             "trivial ctor has argument but isn't a copy/move ctor");
865
866      Expr *Arg = E->getArg(0);
867      assert(CGM.getContext().hasSameUnqualifiedType(Ty, Arg->getType()) &&
868             "argument to copy ctor is of wrong type");
869
870      return Visit(Arg);
871    }
872
873    return CGM.EmitNullConstant(Ty);
874  }
875
876  llvm::Constant *VisitStringLiteral(StringLiteral *E) {
877    return CGM.GetConstantArrayFromStringLiteral(E);
878  }
879
880  llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
881    // This must be an @encode initializing an array in a static initializer.
882    // Don't emit it as the address of the string, emit the string data itself
883    // as an inline array.
884    std::string Str;
885    CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str);
886    const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType());
887
888    // Resize the string to the right size, adding zeros at the end, or
889    // truncating as needed.
890    Str.resize(CAT->getSize().getZExtValue(), '\0');
891    return llvm::ConstantDataArray::getString(VMContext, Str, false);
892  }
893
894  llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) {
895    return Visit(E->getSubExpr());
896  }
897
898  // Utility methods
899  llvm::Type *ConvertType(QualType T) {
900    return CGM.getTypes().ConvertType(T);
901  }
902
903public:
904  llvm::Constant *EmitLValue(APValue::LValueBase LVBase) {
905    if (const ValueDecl *Decl = LVBase.dyn_cast<const ValueDecl*>()) {
906      if (Decl->hasAttr<WeakRefAttr>())
907        return CGM.GetWeakRefReference(Decl);
908      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
909        return CGM.GetAddrOfFunction(FD);
910      if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) {
911        // We can never refer to a variable with local storage.
912        if (!VD->hasLocalStorage()) {
913          if (VD->isFileVarDecl() || VD->hasExternalStorage())
914            return CGM.GetAddrOfGlobalVar(VD);
915          else if (VD->isLocalVarDecl()) {
916            assert(CGF && "Can't access static local vars without CGF");
917            return CGF->GetAddrOfStaticLocalVar(VD);
918          }
919        }
920      }
921      return 0;
922    }
923
924    Expr *E = const_cast<Expr*>(LVBase.get<const Expr*>());
925    switch (E->getStmtClass()) {
926    default: break;
927    case Expr::CompoundLiteralExprClass: {
928      // Note that due to the nature of compound literals, this is guaranteed
929      // to be the only use of the variable, so we just generate it here.
930      CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
931      llvm::Constant* C = CGM.EmitConstantExpr(CLE->getInitializer(),
932                                               CLE->getType(), CGF);
933      // FIXME: "Leaked" on failure.
934      if (C)
935        C = new llvm::GlobalVariable(CGM.getModule(), C->getType(),
936                                     E->getType().isConstant(CGM.getContext()),
937                                     llvm::GlobalValue::InternalLinkage,
938                                     C, ".compoundliteral", 0,
939                                     llvm::GlobalVariable::NotThreadLocal,
940                          CGM.getContext().getTargetAddressSpace(E->getType()));
941      return C;
942    }
943    case Expr::StringLiteralClass:
944      return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E));
945    case Expr::ObjCEncodeExprClass:
946      return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E));
947    case Expr::ObjCStringLiteralClass: {
948      ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E);
949      llvm::Constant *C =
950          CGM.getObjCRuntime().GenerateConstantString(SL->getString());
951      return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType()));
952    }
953    case Expr::PredefinedExprClass: {
954      unsigned Type = cast<PredefinedExpr>(E)->getIdentType();
955      if (CGF) {
956        LValue Res = CGF->EmitPredefinedLValue(cast<PredefinedExpr>(E));
957        return cast<llvm::Constant>(Res.getAddress());
958      } else if (Type == PredefinedExpr::PrettyFunction) {
959        return CGM.GetAddrOfConstantCString("top level", ".tmp");
960      }
961
962      return CGM.GetAddrOfConstantCString("", ".tmp");
963    }
964    case Expr::AddrLabelExprClass: {
965      assert(CGF && "Invalid address of label expression outside function.");
966      llvm::Constant *Ptr =
967        CGF->GetAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel());
968      return llvm::ConstantExpr::getBitCast(Ptr, ConvertType(E->getType()));
969    }
970    case Expr::CallExprClass: {
971      CallExpr* CE = cast<CallExpr>(E);
972      unsigned builtin = CE->isBuiltinCall();
973      if (builtin !=
974            Builtin::BI__builtin___CFStringMakeConstantString &&
975          builtin !=
976            Builtin::BI__builtin___NSStringMakeConstantString)
977        break;
978      const Expr *Arg = CE->getArg(0)->IgnoreParenCasts();
979      const StringLiteral *Literal = cast<StringLiteral>(Arg);
980      if (builtin ==
981            Builtin::BI__builtin___NSStringMakeConstantString) {
982        return CGM.getObjCRuntime().GenerateConstantString(Literal);
983      }
984      // FIXME: need to deal with UCN conversion issues.
985      return CGM.GetAddrOfConstantCFString(Literal);
986    }
987    case Expr::BlockExprClass: {
988      std::string FunctionName;
989      if (CGF)
990        FunctionName = CGF->CurFn->getName();
991      else
992        FunctionName = "global";
993
994      return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str());
995    }
996    case Expr::CXXTypeidExprClass: {
997      CXXTypeidExpr *Typeid = cast<CXXTypeidExpr>(E);
998      QualType T;
999      if (Typeid->isTypeOperand())
1000        T = Typeid->getTypeOperand();
1001      else
1002        T = Typeid->getExprOperand()->getType();
1003      return CGM.GetAddrOfRTTIDescriptor(T);
1004    }
1005    }
1006
1007    return 0;
1008  }
1009};
1010
1011}  // end anonymous namespace.
1012
1013llvm::Constant *CodeGenModule::EmitConstantInit(const VarDecl &D,
1014                                                CodeGenFunction *CGF) {
1015  if (const APValue *Value = D.evaluateValue())
1016    return EmitConstantValueForMemory(*Value, D.getType(), CGF);
1017
1018  // FIXME: Implement C++11 [basic.start.init]p2: if the initializer of a
1019  // reference is a constant expression, and the reference binds to a temporary,
1020  // then constant initialization is performed. ConstExprEmitter will
1021  // incorrectly emit a prvalue constant in this case, and the calling code
1022  // interprets that as the (pointer) value of the reference, rather than the
1023  // desired value of the referee.
1024  if (D.getType()->isReferenceType())
1025    return 0;
1026
1027  const Expr *E = D.getInit();
1028  assert(E && "No initializer to emit");
1029
1030  llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
1031  if (C && C->getType()->isIntegerTy(1)) {
1032    llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
1033    C = llvm::ConstantExpr::getZExt(C, BoolTy);
1034  }
1035  return C;
1036}
1037
1038llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
1039                                                QualType DestType,
1040                                                CodeGenFunction *CGF) {
1041  Expr::EvalResult Result;
1042
1043  bool Success = false;
1044
1045  if (DestType->isReferenceType())
1046    Success = E->EvaluateAsLValue(Result, Context);
1047  else
1048    Success = E->EvaluateAsRValue(Result, Context);
1049
1050  llvm::Constant *C = 0;
1051  if (Success && !Result.HasSideEffects)
1052    C = EmitConstantValue(Result.Val, DestType, CGF);
1053  else
1054    C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
1055
1056  if (C && C->getType()->isIntegerTy(1)) {
1057    llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
1058    C = llvm::ConstantExpr::getZExt(C, BoolTy);
1059  }
1060  return C;
1061}
1062
1063llvm::Constant *CodeGenModule::EmitConstantValue(const APValue &Value,
1064                                                 QualType DestType,
1065                                                 CodeGenFunction *CGF) {
1066  switch (Value.getKind()) {
1067  case APValue::Uninitialized:
1068    llvm_unreachable("Constant expressions should be initialized.");
1069  case APValue::LValue: {
1070    llvm::Type *DestTy = getTypes().ConvertTypeForMem(DestType);
1071    llvm::Constant *Offset =
1072      llvm::ConstantInt::get(Int64Ty, Value.getLValueOffset().getQuantity());
1073
1074    llvm::Constant *C;
1075    if (APValue::LValueBase LVBase = Value.getLValueBase()) {
1076      // An array can be represented as an lvalue referring to the base.
1077      if (isa<llvm::ArrayType>(DestTy)) {
1078        assert(Offset->isNullValue() && "offset on array initializer");
1079        return ConstExprEmitter(*this, CGF).Visit(
1080          const_cast<Expr*>(LVBase.get<const Expr*>()));
1081      }
1082
1083      C = ConstExprEmitter(*this, CGF).EmitLValue(LVBase);
1084
1085      // Apply offset if necessary.
1086      if (!Offset->isNullValue()) {
1087        llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Int8PtrTy);
1088        Casted = llvm::ConstantExpr::getGetElementPtr(Casted, Offset);
1089        C = llvm::ConstantExpr::getBitCast(Casted, C->getType());
1090      }
1091
1092      // Convert to the appropriate type; this could be an lvalue for
1093      // an integer.
1094      if (isa<llvm::PointerType>(DestTy))
1095        return llvm::ConstantExpr::getBitCast(C, DestTy);
1096
1097      return llvm::ConstantExpr::getPtrToInt(C, DestTy);
1098    } else {
1099      C = Offset;
1100
1101      // Convert to the appropriate type; this could be an lvalue for
1102      // an integer.
1103      if (isa<llvm::PointerType>(DestTy))
1104        return llvm::ConstantExpr::getIntToPtr(C, DestTy);
1105
1106      // If the types don't match this should only be a truncate.
1107      if (C->getType() != DestTy)
1108        return llvm::ConstantExpr::getTrunc(C, DestTy);
1109
1110      return C;
1111    }
1112  }
1113  case APValue::Int:
1114    return llvm::ConstantInt::get(VMContext, Value.getInt());
1115  case APValue::ComplexInt: {
1116    llvm::Constant *Complex[2];
1117
1118    Complex[0] = llvm::ConstantInt::get(VMContext,
1119                                        Value.getComplexIntReal());
1120    Complex[1] = llvm::ConstantInt::get(VMContext,
1121                                        Value.getComplexIntImag());
1122
1123    // FIXME: the target may want to specify that this is packed.
1124    llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(),
1125                                                  Complex[1]->getType(),
1126                                                  NULL);
1127    return llvm::ConstantStruct::get(STy, Complex);
1128  }
1129  case APValue::Float: {
1130    const llvm::APFloat &Init = Value.getFloat();
1131    if (&Init.getSemantics() == &llvm::APFloat::IEEEhalf)
1132      return llvm::ConstantInt::get(VMContext, Init.bitcastToAPInt());
1133    else
1134      return llvm::ConstantFP::get(VMContext, Init);
1135  }
1136  case APValue::ComplexFloat: {
1137    llvm::Constant *Complex[2];
1138
1139    Complex[0] = llvm::ConstantFP::get(VMContext,
1140                                       Value.getComplexFloatReal());
1141    Complex[1] = llvm::ConstantFP::get(VMContext,
1142                                       Value.getComplexFloatImag());
1143
1144    // FIXME: the target may want to specify that this is packed.
1145    llvm::StructType *STy = llvm::StructType::get(Complex[0]->getType(),
1146                                                  Complex[1]->getType(),
1147                                                  NULL);
1148    return llvm::ConstantStruct::get(STy, Complex);
1149  }
1150  case APValue::Vector: {
1151    SmallVector<llvm::Constant *, 4> Inits;
1152    unsigned NumElts = Value.getVectorLength();
1153
1154    for (unsigned i = 0; i != NumElts; ++i) {
1155      const APValue &Elt = Value.getVectorElt(i);
1156      if (Elt.isInt())
1157        Inits.push_back(llvm::ConstantInt::get(VMContext, Elt.getInt()));
1158      else
1159        Inits.push_back(llvm::ConstantFP::get(VMContext, Elt.getFloat()));
1160    }
1161    return llvm::ConstantVector::get(Inits);
1162  }
1163  case APValue::AddrLabelDiff: {
1164    const AddrLabelExpr *LHSExpr = Value.getAddrLabelDiffLHS();
1165    const AddrLabelExpr *RHSExpr = Value.getAddrLabelDiffRHS();
1166    llvm::Constant *LHS = EmitConstantExpr(LHSExpr, LHSExpr->getType(), CGF);
1167    llvm::Constant *RHS = EmitConstantExpr(RHSExpr, RHSExpr->getType(), CGF);
1168
1169    // Compute difference
1170    llvm::Type *ResultType = getTypes().ConvertType(DestType);
1171    LHS = llvm::ConstantExpr::getPtrToInt(LHS, IntPtrTy);
1172    RHS = llvm::ConstantExpr::getPtrToInt(RHS, IntPtrTy);
1173    llvm::Constant *AddrLabelDiff = llvm::ConstantExpr::getSub(LHS, RHS);
1174
1175    // LLVM is a bit sensitive about the exact format of the
1176    // address-of-label difference; make sure to truncate after
1177    // the subtraction.
1178    return llvm::ConstantExpr::getTruncOrBitCast(AddrLabelDiff, ResultType);
1179  }
1180  case APValue::Struct:
1181  case APValue::Union:
1182    return ConstStructBuilder::BuildStruct(*this, CGF, Value, DestType);
1183  case APValue::Array: {
1184    const ArrayType *CAT = Context.getAsArrayType(DestType);
1185    unsigned NumElements = Value.getArraySize();
1186    unsigned NumInitElts = Value.getArrayInitializedElts();
1187
1188    std::vector<llvm::Constant*> Elts;
1189    Elts.reserve(NumElements);
1190
1191    // Emit array filler, if there is one.
1192    llvm::Constant *Filler = 0;
1193    if (Value.hasArrayFiller())
1194      Filler = EmitConstantValueForMemory(Value.getArrayFiller(),
1195                                          CAT->getElementType(), CGF);
1196
1197    // Emit initializer elements.
1198    llvm::Type *CommonElementType = 0;
1199    for (unsigned I = 0; I < NumElements; ++I) {
1200      llvm::Constant *C = Filler;
1201      if (I < NumInitElts)
1202        C = EmitConstantValueForMemory(Value.getArrayInitializedElt(I),
1203                                       CAT->getElementType(), CGF);
1204      if (I == 0)
1205        CommonElementType = C->getType();
1206      else if (C->getType() != CommonElementType)
1207        CommonElementType = 0;
1208      Elts.push_back(C);
1209    }
1210
1211    if (!CommonElementType) {
1212      // FIXME: Try to avoid packing the array
1213      std::vector<llvm::Type*> Types;
1214      Types.reserve(NumElements);
1215      for (unsigned i = 0, e = Elts.size(); i < e; ++i)
1216        Types.push_back(Elts[i]->getType());
1217      llvm::StructType *SType = llvm::StructType::get(VMContext, Types, true);
1218      return llvm::ConstantStruct::get(SType, Elts);
1219    }
1220
1221    llvm::ArrayType *AType =
1222      llvm::ArrayType::get(CommonElementType, NumElements);
1223    return llvm::ConstantArray::get(AType, Elts);
1224  }
1225  case APValue::MemberPointer:
1226    return getCXXABI().EmitMemberPointer(Value, DestType);
1227  }
1228  llvm_unreachable("Unknown APValue kind");
1229}
1230
1231llvm::Constant *
1232CodeGenModule::EmitConstantValueForMemory(const APValue &Value,
1233                                          QualType DestType,
1234                                          CodeGenFunction *CGF) {
1235  llvm::Constant *C = EmitConstantValue(Value, DestType, CGF);
1236  if (C->getType()->isIntegerTy(1)) {
1237    llvm::Type *BoolTy = getTypes().ConvertTypeForMem(DestType);
1238    C = llvm::ConstantExpr::getZExt(C, BoolTy);
1239  }
1240  return C;
1241}
1242
1243llvm::Constant *
1244CodeGenModule::GetAddrOfConstantCompoundLiteral(const CompoundLiteralExpr *E) {
1245  assert(E->isFileScope() && "not a file-scope compound literal expr");
1246  return ConstExprEmitter(*this, 0).EmitLValue(E);
1247}
1248
1249llvm::Constant *
1250CodeGenModule::getMemberPointerConstant(const UnaryOperator *uo) {
1251  // Member pointer constants always have a very particular form.
1252  const MemberPointerType *type = cast<MemberPointerType>(uo->getType());
1253  const ValueDecl *decl = cast<DeclRefExpr>(uo->getSubExpr())->getDecl();
1254
1255  // A member function pointer.
1256  if (const CXXMethodDecl *method = dyn_cast<CXXMethodDecl>(decl))
1257    return getCXXABI().EmitMemberPointer(method);
1258
1259  // Otherwise, a member data pointer.
1260  uint64_t fieldOffset = getContext().getFieldOffset(decl);
1261  CharUnits chars = getContext().toCharUnitsFromBits((int64_t) fieldOffset);
1262  return getCXXABI().EmitMemberDataPointer(type, chars);
1263}
1264
1265static void
1266FillInNullDataMemberPointers(CodeGenModule &CGM, QualType T,
1267                             SmallVectorImpl<llvm::Constant *> &Elements,
1268                             uint64_t StartOffset) {
1269  assert(StartOffset % CGM.getContext().getCharWidth() == 0 &&
1270         "StartOffset not byte aligned!");
1271
1272  if (CGM.getTypes().isZeroInitializable(T))
1273    return;
1274
1275  if (const ConstantArrayType *CAT =
1276        CGM.getContext().getAsConstantArrayType(T)) {
1277    QualType ElementTy = CAT->getElementType();
1278    uint64_t ElementSize = CGM.getContext().getTypeSize(ElementTy);
1279
1280    for (uint64_t I = 0, E = CAT->getSize().getZExtValue(); I != E; ++I) {
1281      FillInNullDataMemberPointers(CGM, ElementTy, Elements,
1282                                   StartOffset + I * ElementSize);
1283    }
1284  } else if (const RecordType *RT = T->getAs<RecordType>()) {
1285    const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1286    const ASTRecordLayout &Layout = CGM.getContext().getASTRecordLayout(RD);
1287
1288    // Go through all bases and fill in any null pointer to data members.
1289    for (CXXRecordDecl::base_class_const_iterator I = RD->bases_begin(),
1290         E = RD->bases_end(); I != E; ++I) {
1291      if (I->isVirtual()) {
1292        // Ignore virtual bases.
1293        continue;
1294      }
1295
1296      const CXXRecordDecl *BaseDecl =
1297      cast<CXXRecordDecl>(I->getType()->getAs<RecordType>()->getDecl());
1298
1299      // Ignore empty bases.
1300      if (BaseDecl->isEmpty())
1301        continue;
1302
1303      // Ignore bases that don't have any pointer to data members.
1304      if (CGM.getTypes().isZeroInitializable(BaseDecl))
1305        continue;
1306
1307      uint64_t BaseOffset =
1308        CGM.getContext().toBits(Layout.getBaseClassOffset(BaseDecl));
1309      FillInNullDataMemberPointers(CGM, I->getType(),
1310                                   Elements, StartOffset + BaseOffset);
1311    }
1312
1313    // Visit all fields.
1314    unsigned FieldNo = 0;
1315    for (RecordDecl::field_iterator I = RD->field_begin(),
1316         E = RD->field_end(); I != E; ++I, ++FieldNo) {
1317      QualType FieldType = I->getType();
1318
1319      if (CGM.getTypes().isZeroInitializable(FieldType))
1320        continue;
1321
1322      uint64_t FieldOffset = StartOffset + Layout.getFieldOffset(FieldNo);
1323      FillInNullDataMemberPointers(CGM, FieldType, Elements, FieldOffset);
1324    }
1325  } else {
1326    assert(T->isMemberPointerType() && "Should only see member pointers here!");
1327    assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() &&
1328           "Should only see pointers to data members here!");
1329
1330    CharUnits StartIndex = CGM.getContext().toCharUnitsFromBits(StartOffset);
1331    CharUnits EndIndex = StartIndex + CGM.getContext().getTypeSizeInChars(T);
1332
1333    // FIXME: hardcodes Itanium member pointer representation!
1334    llvm::Constant *NegativeOne =
1335      llvm::ConstantInt::get(CGM.Int8Ty, -1ULL, /*isSigned*/true);
1336
1337    // Fill in the null data member pointer.
1338    for (CharUnits I = StartIndex; I != EndIndex; ++I)
1339      Elements[I.getQuantity()] = NegativeOne;
1340  }
1341}
1342
1343static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
1344                                               llvm::Type *baseType,
1345                                               const CXXRecordDecl *base);
1346
1347static llvm::Constant *EmitNullConstant(CodeGenModule &CGM,
1348                                        const CXXRecordDecl *record,
1349                                        bool asCompleteObject) {
1350  const CGRecordLayout &layout = CGM.getTypes().getCGRecordLayout(record);
1351  llvm::StructType *structure =
1352    (asCompleteObject ? layout.getLLVMType()
1353                      : layout.getBaseSubobjectLLVMType());
1354
1355  unsigned numElements = structure->getNumElements();
1356  std::vector<llvm::Constant *> elements(numElements);
1357
1358  // Fill in all the bases.
1359  for (CXXRecordDecl::base_class_const_iterator
1360         I = record->bases_begin(), E = record->bases_end(); I != E; ++I) {
1361    if (I->isVirtual()) {
1362      // Ignore virtual bases; if we're laying out for a complete
1363      // object, we'll lay these out later.
1364      continue;
1365    }
1366
1367    const CXXRecordDecl *base =
1368      cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl());
1369
1370    // Ignore empty bases.
1371    if (base->isEmpty())
1372      continue;
1373
1374    unsigned fieldIndex = layout.getNonVirtualBaseLLVMFieldNo(base);
1375    llvm::Type *baseType = structure->getElementType(fieldIndex);
1376    elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
1377  }
1378
1379  // Fill in all the fields.
1380  for (RecordDecl::field_iterator I = record->field_begin(),
1381         E = record->field_end(); I != E; ++I) {
1382    const FieldDecl *field = *I;
1383
1384    // Fill in non-bitfields. (Bitfields always use a zero pattern, which we
1385    // will fill in later.)
1386    if (!field->isBitField()) {
1387      unsigned fieldIndex = layout.getLLVMFieldNo(field);
1388      elements[fieldIndex] = CGM.EmitNullConstant(field->getType());
1389    }
1390
1391    // For unions, stop after the first named field.
1392    if (record->isUnion() && field->getDeclName())
1393      break;
1394  }
1395
1396  // Fill in the virtual bases, if we're working with the complete object.
1397  if (asCompleteObject) {
1398    for (CXXRecordDecl::base_class_const_iterator
1399           I = record->vbases_begin(), E = record->vbases_end(); I != E; ++I) {
1400      const CXXRecordDecl *base =
1401        cast<CXXRecordDecl>(I->getType()->castAs<RecordType>()->getDecl());
1402
1403      // Ignore empty bases.
1404      if (base->isEmpty())
1405        continue;
1406
1407      unsigned fieldIndex = layout.getVirtualBaseIndex(base);
1408
1409      // We might have already laid this field out.
1410      if (elements[fieldIndex]) continue;
1411
1412      llvm::Type *baseType = structure->getElementType(fieldIndex);
1413      elements[fieldIndex] = EmitNullConstantForBase(CGM, baseType, base);
1414    }
1415  }
1416
1417  // Now go through all other fields and zero them out.
1418  for (unsigned i = 0; i != numElements; ++i) {
1419    if (!elements[i])
1420      elements[i] = llvm::Constant::getNullValue(structure->getElementType(i));
1421  }
1422
1423  return llvm::ConstantStruct::get(structure, elements);
1424}
1425
1426/// Emit the null constant for a base subobject.
1427static llvm::Constant *EmitNullConstantForBase(CodeGenModule &CGM,
1428                                               llvm::Type *baseType,
1429                                               const CXXRecordDecl *base) {
1430  const CGRecordLayout &baseLayout = CGM.getTypes().getCGRecordLayout(base);
1431
1432  // Just zero out bases that don't have any pointer to data members.
1433  if (baseLayout.isZeroInitializableAsBase())
1434    return llvm::Constant::getNullValue(baseType);
1435
1436  // If the base type is a struct, we can just use its null constant.
1437  if (isa<llvm::StructType>(baseType)) {
1438    return EmitNullConstant(CGM, base, /*complete*/ false);
1439  }
1440
1441  // Otherwise, some bases are represented as arrays of i8 if the size
1442  // of the base is smaller than its corresponding LLVM type.  Figure
1443  // out how many elements this base array has.
1444  llvm::ArrayType *baseArrayType = cast<llvm::ArrayType>(baseType);
1445  unsigned numBaseElements = baseArrayType->getNumElements();
1446
1447  // Fill in null data member pointers.
1448  SmallVector<llvm::Constant *, 16> baseElements(numBaseElements);
1449  FillInNullDataMemberPointers(CGM, CGM.getContext().getTypeDeclType(base),
1450                               baseElements, 0);
1451
1452  // Now go through all other elements and zero them out.
1453  if (numBaseElements) {
1454    llvm::Constant *i8_zero = llvm::Constant::getNullValue(CGM.Int8Ty);
1455    for (unsigned i = 0; i != numBaseElements; ++i) {
1456      if (!baseElements[i])
1457        baseElements[i] = i8_zero;
1458    }
1459  }
1460
1461  return llvm::ConstantArray::get(baseArrayType, baseElements);
1462}
1463
1464llvm::Constant *CodeGenModule::EmitNullConstant(QualType T) {
1465  if (getTypes().isZeroInitializable(T))
1466    return llvm::Constant::getNullValue(getTypes().ConvertTypeForMem(T));
1467
1468  if (const ConstantArrayType *CAT = Context.getAsConstantArrayType(T)) {
1469    llvm::ArrayType *ATy =
1470      cast<llvm::ArrayType>(getTypes().ConvertTypeForMem(T));
1471
1472    QualType ElementTy = CAT->getElementType();
1473
1474    llvm::Constant *Element = EmitNullConstant(ElementTy);
1475    unsigned NumElements = CAT->getSize().getZExtValue();
1476
1477    if (Element->isNullValue())
1478      return llvm::ConstantAggregateZero::get(ATy);
1479
1480    SmallVector<llvm::Constant *, 8> Array(NumElements, Element);
1481    return llvm::ConstantArray::get(ATy, Array);
1482  }
1483
1484  if (const RecordType *RT = T->getAs<RecordType>()) {
1485    const CXXRecordDecl *RD = cast<CXXRecordDecl>(RT->getDecl());
1486    return ::EmitNullConstant(*this, RD, /*complete object*/ true);
1487  }
1488
1489  assert(T->isMemberPointerType() && "Should only see member pointers here!");
1490  assert(!T->getAs<MemberPointerType>()->getPointeeType()->isFunctionType() &&
1491         "Should only see pointers to data members here!");
1492
1493  // Itanium C++ ABI 2.3:
1494  //   A NULL pointer is represented as -1.
1495  return getCXXABI().EmitNullMemberPointer(T->castAs<MemberPointerType>());
1496}
1497
1498llvm::Constant *
1499CodeGenModule::EmitNullConstantForBase(const CXXRecordDecl *Record) {
1500  return ::EmitNullConstant(*this, Record, false);
1501}
1502