CGExprConstant.cpp revision 069880ef6a2ecfdbc98a4980de53d3902499e83b 
1//===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Constant Expr nodes as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "CodeGenModule.h"
16#include "CGObjCRuntime.h"
17#include "clang/AST/APValue.h"
18#include "clang/AST/ASTContext.h"
19#include "clang/AST/StmtVisitor.h"
20#include "llvm/Constants.h"
21#include "llvm/Function.h"
22#include "llvm/GlobalVariable.h"
23#include "llvm/Support/Compiler.h"
24#include "llvm/Target/TargetData.h"
25using namespace clang;
26using namespace CodeGen;
27
28namespace  {
29class VISIBILITY_HIDDEN ConstExprEmitter :
30  public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
31  CodeGenModule &CGM;
32  CodeGenFunction *CGF;
33public:
34  ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf)
35    : CGM(cgm), CGF(cgf) {
36  }
37
38  //===--------------------------------------------------------------------===//
39  //                            Visitor Methods
40  //===--------------------------------------------------------------------===//
41
42  llvm::Constant *VisitStmt(Stmt *S) {
43    return 0;
44  }
45
46  llvm::Constant *VisitParenExpr(ParenExpr *PE) {
47    return Visit(PE->getSubExpr());
48  }
49
50  llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
51    return Visit(E->getInitializer());
52  }
53
54  llvm::Constant *VisitCastExpr(CastExpr* E) {
55    // GCC cast to union extension
56    if (E->getType()->isUnionType()) {
57      const llvm::Type *Ty = ConvertType(E->getType());
58      return EmitUnion(CGM.EmitConstantExpr(E->getSubExpr(), CGF), Ty);
59    }
60    if (CGM.getContext().getCanonicalType(E->getSubExpr()->getType()) ==
61        CGM.getContext().getCanonicalType(E->getType())) {
62      return Visit(E->getSubExpr());
63    }
64    return 0;
65  }
66
67  llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
68    return Visit(DAE->getExpr());
69  }
70
71  llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) {
72    std::vector<llvm::Constant*> Elts;
73    const llvm::ArrayType *AType =
74        cast<llvm::ArrayType>(ConvertType(ILE->getType()));
75    unsigned NumInitElements = ILE->getNumInits();
76    // FIXME: Check for wide strings
77    // FIXME: Check for NumInitElements exactly equal to 1??
78    if (NumInitElements > 0 &&
79        (isa<StringLiteral>(ILE->getInit(0)) ||
80         isa<ObjCEncodeExpr>(ILE->getInit(0))) &&
81        ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType())
82      return Visit(ILE->getInit(0));
83    const llvm::Type *ElemTy = AType->getElementType();
84    unsigned NumElements = AType->getNumElements();
85
86    // Initialising an array requires us to automatically
87    // initialise any elements that have not been initialised explicitly
88    unsigned NumInitableElts = std::min(NumInitElements, NumElements);
89
90    // Copy initializer elements.
91    unsigned i = 0;
92    bool RewriteType = false;
93    for (; i < NumInitableElts; ++i) {
94      llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF);
95      if (!C)
96        return 0;
97      RewriteType |= (C->getType() != ElemTy);
98      Elts.push_back(C);
99    }
100
101    // Initialize remaining array elements.
102    for (; i < NumElements; ++i)
103      Elts.push_back(llvm::Constant::getNullValue(ElemTy));
104
105    if (RewriteType) {
106      // FIXME: Try to avoid packing the array
107      std::vector<const llvm::Type*> Types;
108      for (unsigned i = 0; i < Elts.size(); ++i)
109        Types.push_back(Elts[i]->getType());
110      const llvm::StructType *SType = llvm::StructType::get(Types, true);
111      return llvm::ConstantStruct::get(SType, Elts);
112    }
113
114    return llvm::ConstantArray::get(AType, Elts);
115  }
116
117  void InsertBitfieldIntoStruct(std::vector<llvm::Constant*>& Elts,
118                                FieldDecl* Field, Expr* E) {
119    // Calculate the value to insert
120    llvm::Constant *C = CGM.EmitConstantExpr(E, CGF);
121    if (!C)
122      return;
123
124    llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C);
125    if (!CI) {
126      CGM.ErrorUnsupported(E, "bitfield initialization");
127      return;
128    }
129    llvm::APInt V = CI->getValue();
130
131    // Calculate information about the relevant field
132    const llvm::Type* Ty = CI->getType();
133    const llvm::TargetData &TD = CGM.getTypes().getTargetData();
134    unsigned size = TD.getTypePaddedSizeInBits(Ty);
135    unsigned fieldOffset = CGM.getTypes().getLLVMFieldNo(Field) * size;
136    CodeGenTypes::BitFieldInfo bitFieldInfo =
137        CGM.getTypes().getBitFieldInfo(Field);
138    fieldOffset += bitFieldInfo.Begin;
139
140    // Find where to start the insertion
141    // FIXME: This is O(n^2) in the number of bit-fields!
142    // FIXME: This won't work if the struct isn't completely packed!
143    unsigned offset = 0, i = 0;
144    while (offset < (fieldOffset & -8))
145      offset += TD.getTypePaddedSizeInBits(Elts[i++]->getType());
146
147    // Advance over 0 sized elements (must terminate in bounds since
148    // the bitfield must have a size).
149    while (TD.getTypePaddedSizeInBits(Elts[i]->getType()) == 0)
150      ++i;
151
152    // Promote the size of V if necessary
153    // FIXME: This should never occur, but currently it can because
154    // initializer constants are cast to bool, and because clang is
155    // not enforcing bitfield width limits.
156    if (bitFieldInfo.Size > V.getBitWidth())
157      V.zext(bitFieldInfo.Size);
158
159    // Insert the bits into the struct
160    // FIXME: This algorthm is only correct on X86!
161    // FIXME: THis algorthm assumes bit-fields only have byte-size elements!
162    unsigned bitsToInsert = bitFieldInfo.Size;
163    unsigned curBits = std::min(8 - (fieldOffset & 7), bitsToInsert);
164    unsigned byte = V.getLoBits(curBits).getZExtValue() << (fieldOffset & 7);
165    do {
166      llvm::Constant* byteC = llvm::ConstantInt::get(llvm::Type::Int8Ty, byte);
167      Elts[i] = llvm::ConstantExpr::getOr(Elts[i], byteC);
168      ++i;
169      V = V.lshr(curBits);
170      bitsToInsert -= curBits;
171
172      if (!bitsToInsert)
173        break;
174
175      curBits = bitsToInsert > 8 ? 8 : bitsToInsert;
176      byte = V.getLoBits(curBits).getZExtValue();
177    } while (true);
178  }
179
180  llvm::Constant *EmitStructInitialization(InitListExpr *ILE) {
181    const llvm::StructType *SType =
182        cast<llvm::StructType>(ConvertType(ILE->getType()));
183    RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl();
184    std::vector<llvm::Constant*> Elts;
185
186    // Initialize the whole structure to zero.
187    for (unsigned i = 0; i < SType->getNumElements(); ++i) {
188      const llvm::Type *FieldTy = SType->getElementType(i);
189      Elts.push_back(llvm::Constant::getNullValue(FieldTy));
190    }
191
192    // Copy initializer elements. Skip padding fields.
193    unsigned EltNo = 0;  // Element no in ILE
194    int FieldNo = 0; // Field no in RecordDecl
195    bool RewriteType = false;
196    for (RecordDecl::field_iterator Field = RD->field_begin(),
197                                 FieldEnd = RD->field_end();
198         EltNo < ILE->getNumInits() && Field != FieldEnd; ++Field) {
199      FieldNo++;
200      if (!Field->getIdentifier())
201        continue;
202
203      if (Field->isBitField()) {
204        InsertBitfieldIntoStruct(Elts, *Field, ILE->getInit(EltNo));
205      } else {
206        unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(*Field);
207        llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(EltNo), CGF);
208        if (!C) return 0;
209        RewriteType |= (C->getType() != Elts[FieldNo]->getType());
210        Elts[FieldNo] = C;
211      }
212      EltNo++;
213    }
214
215    if (RewriteType) {
216      // FIXME: Make this work for non-packed structs
217      assert(SType->isPacked() && "Cannot recreate unpacked structs");
218      std::vector<const llvm::Type*> Types;
219      for (unsigned i = 0; i < Elts.size(); ++i)
220        Types.push_back(Elts[i]->getType());
221      SType = llvm::StructType::get(Types, true);
222    }
223
224    return llvm::ConstantStruct::get(SType, Elts);
225  }
226
227  llvm::Constant *EmitUnion(llvm::Constant *C, const llvm::Type *Ty) {
228    if (!C)
229      return 0;
230
231    // Build a struct with the union sub-element as the first member,
232    // and padded to the appropriate size
233    std::vector<llvm::Constant*> Elts;
234    std::vector<const llvm::Type*> Types;
235    Elts.push_back(C);
236    Types.push_back(C->getType());
237    unsigned CurSize = CGM.getTargetData().getTypePaddedSize(C->getType());
238    unsigned TotalSize = CGM.getTargetData().getTypePaddedSize(Ty);
239    while (CurSize < TotalSize) {
240      Elts.push_back(llvm::Constant::getNullValue(llvm::Type::Int8Ty));
241      Types.push_back(llvm::Type::Int8Ty);
242      CurSize++;
243    }
244
245    // This always generates a packed struct
246    // FIXME: Try to generate an unpacked struct when we can
247    llvm::StructType* STy = llvm::StructType::get(Types, true);
248    return llvm::ConstantStruct::get(STy, Elts);
249  }
250
251  llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) {
252    const llvm::Type *Ty = ConvertType(ILE->getType());
253
254    // If this is an empty initializer list, we value-initialize the
255    // union.
256    if (ILE->getNumInits() == 0)
257      return llvm::Constant::getNullValue(Ty);
258
259    FieldDecl* curField = ILE->getInitializedFieldInUnion();
260    if (!curField) {
261      // There's no field to initialize, so value-initialize the union.
262#ifndef NDEBUG
263      // Make sure that it's really an empty and not a failure of
264      // semantic analysis.
265      RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl();
266      for (RecordDecl::field_iterator Field = RD->field_begin(),
267                                   FieldEnd = RD->field_end();
268           Field != FieldEnd; ++Field)
269        assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
270#endif
271      return llvm::Constant::getNullValue(Ty);
272    }
273
274    if (curField->isBitField()) {
275      // Create a dummy struct for bit-field insertion
276      unsigned NumElts = CGM.getTargetData().getTypePaddedSize(Ty) / 8;
277      llvm::Constant* NV = llvm::Constant::getNullValue(llvm::Type::Int8Ty);
278      std::vector<llvm::Constant*> Elts(NumElts, NV);
279
280      InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(0));
281      const llvm::ArrayType *RetTy =
282          llvm::ArrayType::get(NV->getType(), NumElts);
283      return llvm::ConstantArray::get(RetTy, Elts);
284    }
285
286    return EmitUnion(CGM.EmitConstantExpr(ILE->getInit(0), CGF), Ty);
287  }
288
289  llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) {
290    const llvm::VectorType *VType =
291        cast<llvm::VectorType>(ConvertType(ILE->getType()));
292    const llvm::Type *ElemTy = VType->getElementType();
293    std::vector<llvm::Constant*> Elts;
294    unsigned NumElements = VType->getNumElements();
295    unsigned NumInitElements = ILE->getNumInits();
296
297    unsigned NumInitableElts = std::min(NumInitElements, NumElements);
298
299    // Copy initializer elements.
300    unsigned i = 0;
301    for (; i < NumInitableElts; ++i) {
302      llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF);
303      if (!C)
304        return 0;
305      Elts.push_back(C);
306    }
307
308    for (; i < NumElements; ++i)
309      Elts.push_back(llvm::Constant::getNullValue(ElemTy));
310
311    return llvm::ConstantVector::get(VType, Elts);
312  }
313
314  llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) {
315    const llvm::Type* RetTy = CGM.getTypes().ConvertType(E->getType());
316    return llvm::Constant::getNullValue(RetTy);
317  }
318
319  llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
320    if (ILE->getType()->isScalarType()) {
321      // We have a scalar in braces. Just use the first element.
322      if (ILE->getNumInits() > 0)
323        return CGM.EmitConstantExpr(ILE->getInit(0), CGF);
324
325      const llvm::Type* RetTy = CGM.getTypes().ConvertType(ILE->getType());
326      return llvm::Constant::getNullValue(RetTy);
327    }
328
329    if (ILE->getType()->isArrayType())
330      return EmitArrayInitialization(ILE);
331
332    if (ILE->getType()->isStructureType())
333      return EmitStructInitialization(ILE);
334
335    if (ILE->getType()->isUnionType())
336      return EmitUnionInitialization(ILE);
337
338    if (ILE->getType()->isVectorType())
339      return EmitVectorInitialization(ILE);
340
341    assert(0 && "Unable to handle InitListExpr");
342    // Get rid of control reaches end of void function warning.
343    // Not reached.
344    return 0;
345  }
346
347  llvm::Constant *VisitStringLiteral(StringLiteral *E) {
348    assert(!E->getType()->isPointerType() && "Strings are always arrays");
349
350    // This must be a string initializing an array in a static initializer.
351    // Don't emit it as the address of the string, emit the string data itself
352    // as an inline array.
353    return llvm::ConstantArray::get(CGM.GetStringForStringLiteral(E), false);
354  }
355
356  llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
357    // This must be an @encode initializing an array in a static initializer.
358    // Don't emit it as the address of the string, emit the string data itself
359    // as an inline array.
360    std::string Str;
361    CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str);
362    const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType());
363
364    // Resize the string to the right size, adding zeros at the end, or
365    // truncating as needed.
366    Str.resize(CAT->getSize().getZExtValue(), '\0');
367    return llvm::ConstantArray::get(Str, false);
368  }
369
370  llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) {
371    return Visit(E->getSubExpr());
372  }
373
374  // Utility methods
375  const llvm::Type *ConvertType(QualType T) {
376    return CGM.getTypes().ConvertType(T);
377  }
378
379public:
380  llvm::Constant *EmitLValue(Expr *E) {
381    switch (E->getStmtClass()) {
382    default: break;
383    case Expr::CompoundLiteralExprClass: {
384      // Note that due to the nature of compound literals, this is guaranteed
385      // to be the only use of the variable, so we just generate it here.
386      CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
387      llvm::Constant* C = Visit(CLE->getInitializer());
388      // FIXME: "Leaked" on failure.
389      if (C)
390        C = new llvm::GlobalVariable(C->getType(),
391                                     E->getType().isConstQualified(),
392                                     llvm::GlobalValue::InternalLinkage,
393                                     C, ".compoundliteral", &CGM.getModule());
394      return C;
395    }
396    case Expr::DeclRefExprClass:
397    case Expr::QualifiedDeclRefExprClass: {
398      NamedDecl *Decl = cast<DeclRefExpr>(E)->getDecl();
399      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
400        return CGM.GetAddrOfFunction(FD);
401      if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) {
402        // We can never refer to a variable with local storage.
403        if (!VD->hasLocalStorage()) {
404          if (VD->isFileVarDecl() || VD->hasExternalStorage())
405            return CGM.GetAddrOfGlobalVar(VD);
406          else if (VD->isBlockVarDecl()) {
407            assert(CGF && "Can't access static local vars without CGF");
408            return CGF->GetAddrOfStaticLocalVar(VD);
409          }
410        }
411      }
412      break;
413    }
414    case Expr::StringLiteralClass:
415      return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E));
416    case Expr::ObjCEncodeExprClass:
417      return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E));
418    case Expr::ObjCStringLiteralClass: {
419      ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E);
420      std::string S(SL->getString()->getStrData(),
421                    SL->getString()->getByteLength());
422      llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(S);
423      return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType()));
424    }
425    case Expr::PredefinedExprClass: {
426      // __func__/__FUNCTION__ -> "".  __PRETTY_FUNCTION__ -> "top level".
427      std::string Str;
428      if (cast<PredefinedExpr>(E)->getIdentType() ==
429          PredefinedExpr::PrettyFunction)
430        Str = "top level";
431
432      return CGM.GetAddrOfConstantCString(Str, ".tmp");
433    }
434    case Expr::AddrLabelExprClass: {
435      assert(CGF && "Invalid address of label expression outside function.");
436      unsigned id = CGF->GetIDForAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel());
437      llvm::Constant *C = llvm::ConstantInt::get(llvm::Type::Int32Ty, id);
438      return llvm::ConstantExpr::getIntToPtr(C, ConvertType(E->getType()));
439    }
440    case Expr::CallExprClass: {
441      CallExpr* CE = cast<CallExpr>(E);
442      if (CE->isBuiltinCall(CGM.getContext()) !=
443            Builtin::BI__builtin___CFStringMakeConstantString)
444        break;
445      const Expr *Arg = CE->getArg(0)->IgnoreParenCasts();
446      const StringLiteral *Literal = cast<StringLiteral>(Arg);
447      std::string S(Literal->getStrData(), Literal->getByteLength());
448      return CGM.GetAddrOfConstantCFString(S);
449    }
450    case Expr::BlockExprClass: {
451      std::string FunctionName;
452      if (CGF)
453        FunctionName = CGF->CurFn->getName();
454      else
455        FunctionName = "global";
456
457      return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str());
458    }
459    }
460
461    return 0;
462  }
463};
464
465}  // end anonymous namespace.
466
467llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
468                                                CodeGenFunction *CGF) {
469  Expr::EvalResult Result;
470
471  if (E->Evaluate(Result, Context)) {
472    assert(!Result.HasSideEffects &&
473           "Constant expr should not have any side effects!");
474    switch (Result.Val.getKind()) {
475    case APValue::Uninitialized:
476      assert(0 && "Constant expressions should be initialized.");
477      return 0;
478    case APValue::LValue: {
479      const llvm::Type *DestType = getTypes().ConvertTypeForMem(E->getType());
480      llvm::Constant *Offset =
481        llvm::ConstantInt::get(llvm::Type::Int64Ty,
482                               Result.Val.getLValueOffset());
483
484      llvm::Constant *C;
485      if (const Expr *LVBase = Result.Val.getLValueBase()) {
486        C = ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase));
487
488        // Apply offset if necessary.
489        if (!Offset->isNullValue()) {
490          const llvm::Type *Type =
491            llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
492          llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Type);
493          Casted = llvm::ConstantExpr::getGetElementPtr(Casted, &Offset, 1);
494          C = llvm::ConstantExpr::getBitCast(Casted, C->getType());
495        }
496
497        // Convert to the appropriate type; this could be an lvalue for
498        // an integer.
499        if (isa<llvm::PointerType>(DestType))
500          return llvm::ConstantExpr::getBitCast(C, DestType);
501
502        return llvm::ConstantExpr::getPtrToInt(C, DestType);
503      } else {
504        C = Offset;
505
506        // Convert to the appropriate type; this could be an lvalue for
507        // an integer.
508        if (isa<llvm::PointerType>(DestType))
509          return llvm::ConstantExpr::getIntToPtr(C, DestType);
510
511        // If the types don't match this should only be a truncate.
512        if (C->getType() != DestType)
513          return llvm::ConstantExpr::getTrunc(C, DestType);
514
515        return C;
516      }
517    }
518    case APValue::Int: {
519      llvm::Constant *C = llvm::ConstantInt::get(Result.Val.getInt());
520
521      if (C->getType() == llvm::Type::Int1Ty) {
522        const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
523        C = llvm::ConstantExpr::getZExt(C, BoolTy);
524      }
525      return C;
526    }
527    case APValue::ComplexInt: {
528      llvm::Constant *Complex[2];
529
530      Complex[0] = llvm::ConstantInt::get(Result.Val.getComplexIntReal());
531      Complex[1] = llvm::ConstantInt::get(Result.Val.getComplexIntImag());
532
533      return llvm::ConstantStruct::get(Complex, 2);
534    }
535    case APValue::Float:
536      return llvm::ConstantFP::get(Result.Val.getFloat());
537    case APValue::ComplexFloat: {
538      llvm::Constant *Complex[2];
539
540      Complex[0] = llvm::ConstantFP::get(Result.Val.getComplexFloatReal());
541      Complex[1] = llvm::ConstantFP::get(Result.Val.getComplexFloatImag());
542
543      return llvm::ConstantStruct::get(Complex, 2);
544    }
545    case APValue::Vector: {
546      llvm::SmallVector<llvm::Constant *, 4> Inits;
547      unsigned NumElts = Result.Val.getVectorLength();
548
549      for (unsigned i = 0; i != NumElts; ++i) {
550        APValue &Elt = Result.Val.getVectorElt(i);
551        if (Elt.isInt())
552          Inits.push_back(llvm::ConstantInt::get(Elt.getInt()));
553        else
554          Inits.push_back(llvm::ConstantFP::get(Elt.getFloat()));
555      }
556      return llvm::ConstantVector::get(&Inits[0], Inits.size());
557    }
558    }
559  }
560
561  llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
562  if (C && C->getType() == llvm::Type::Int1Ty) {
563    const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
564    C = llvm::ConstantExpr::getZExt(C, BoolTy);
565  }
566  return C;
567}
568