CGExprConstant.cpp revision 9ca8bb0996bbb8b9dbf69c51cb3d1523559e47e3 
1//===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// This contains code to emit Constant Expr nodes as LLVM code.
11//
12//===----------------------------------------------------------------------===//
13
14#include "CodeGenFunction.h"
15#include "CodeGenModule.h"
16#include "clang/AST/AST.h"
17#include "llvm/Constants.h"
18#include "llvm/Function.h"
19#include "llvm/GlobalVariable.h"
20#include "llvm/Support/Compiler.h"
21#include "llvm/Target/TargetData.h"
22using namespace clang;
23using namespace CodeGen;
24
25namespace  {
26class VISIBILITY_HIDDEN ConstExprEmitter :
27  public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
28  CodeGenModule &CGM;
29  CodeGenFunction *CGF;
30public:
31  ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf)
32    : CGM(cgm), CGF(cgf) {
33  }
34
35  //===--------------------------------------------------------------------===//
36  //                            Visitor Methods
37  //===--------------------------------------------------------------------===//
38
39  llvm::Constant *VisitStmt(Stmt *S) {
40    CGM.WarnUnsupported(S, "constant expression");
41    QualType T = cast<Expr>(S)->getType();
42    return llvm::UndefValue::get(CGM.getTypes().ConvertType(T));
43  }
44
45  llvm::Constant *VisitParenExpr(ParenExpr *PE) {
46    return Visit(PE->getSubExpr());
47  }
48
49  // Leaves
50  llvm::Constant *VisitIntegerLiteral(const IntegerLiteral *E) {
51    return llvm::ConstantInt::get(E->getValue());
52  }
53  llvm::Constant *VisitFloatingLiteral(const FloatingLiteral *E) {
54    return llvm::ConstantFP::get(E->getValue());
55  }
56  llvm::Constant *VisitCharacterLiteral(const CharacterLiteral *E) {
57    return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
58  }
59  llvm::Constant *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
60    return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
61  }
62  llvm::Constant *VisitObjCStringLiteral(const ObjCStringLiteral *E) {
63    return CGM.getObjCRuntime()->GenerateConstantString(
64        E->getString()->getStrData(), E->getString()->getByteLength());
65  }
66
67  llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
68    return Visit(E->getInitializer());
69  }
70
71  llvm::Constant *VisitCastExpr(const CastExpr* E) {
72    llvm::Constant *C = Visit(E->getSubExpr());
73
74    return EmitConversion(C, E->getSubExpr()->getType(), E->getType());
75  }
76
77  llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
78    return Visit(DAE->getExpr());
79  }
80
81  llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) {
82    std::vector<llvm::Constant*> Elts;
83    const llvm::ArrayType *AType =
84        cast<llvm::ArrayType>(ConvertType(ILE->getType()));
85    unsigned NumInitElements = ILE->getNumInits();
86    // FIXME: Check for wide strings
87    if (NumInitElements > 0 && isa<StringLiteral>(ILE->getInit(0)) &&
88        ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType())
89      return Visit(ILE->getInit(0));
90    const llvm::Type *ElemTy = AType->getElementType();
91    unsigned NumElements = AType->getNumElements();
92
93    // Initialising an array requires us to automatically
94    // initialise any elements that have not been initialised explicitly
95    unsigned NumInitableElts = std::min(NumInitElements, NumElements);
96
97    // Copy initializer elements.
98    unsigned i = 0;
99    bool RewriteType = false;
100    for (; i < NumInitableElts; ++i) {
101      llvm::Constant *C = Visit(ILE->getInit(i));
102      RewriteType |= (C->getType() != ElemTy);
103      Elts.push_back(C);
104    }
105
106    // Initialize remaining array elements.
107    for (; i < NumElements; ++i)
108      Elts.push_back(llvm::Constant::getNullValue(ElemTy));
109
110    if (RewriteType) {
111      // FIXME: Try to avoid packing the array
112      std::vector<const llvm::Type*> Types;
113      for (unsigned i = 0; i < Elts.size(); ++i)
114        Types.push_back(Elts[i]->getType());
115      const llvm::StructType *SType = llvm::StructType::get(Types, true);
116      return llvm::ConstantStruct::get(SType, Elts);
117    }
118
119    return llvm::ConstantArray::get(AType, Elts);
120  }
121
122  void InsertBitfieldIntoStruct(std::vector<llvm::Constant*>& Elts,
123                                FieldDecl* Field, Expr* E) {
124    // Calculate the value to insert
125    llvm::Constant *C = Visit(E);
126    llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C);
127    if (!CI) {
128      CGM.WarnUnsupported(E, "bitfield initialization");
129      return;
130    }
131    llvm::APInt V = CI->getValue();
132
133    // Calculate information about the relevant field
134    const llvm::Type* Ty = CI->getType();
135    const llvm::TargetData &TD = CGM.getTypes().getTargetData();
136    unsigned size = TD.getTypeStoreSizeInBits(Ty);
137    unsigned fieldOffset = CGM.getTypes().getLLVMFieldNo(Field) * size;
138    CodeGenTypes::BitFieldInfo bitFieldInfo =
139        CGM.getTypes().getBitFieldInfo(Field);
140    fieldOffset += bitFieldInfo.Begin;
141
142    // Find where to start the insertion
143    // FIXME: This is O(n^2) in the number of bit-fields!
144    // FIXME: This won't work if the struct isn't completely packed!
145    unsigned offset = 0, i = 0;
146    while (offset < (fieldOffset & -8))
147      offset += TD.getTypeStoreSizeInBits(Elts[i++]->getType());
148
149    // Advance over 0 sized elements (must terminate in bounds since
150    // the bitfield must have a size).
151    while (TD.getTypeStoreSizeInBits(Elts[i]->getType()) == 0)
152      ++i;
153
154    // Promote the size of V if necessary
155    // FIXME: This should never occur, but currently it can because
156    // initializer constants are cast to bool, and because clang is
157    // not enforcing bitfield width limits.
158    if (bitFieldInfo.Size > V.getBitWidth())
159      V.zext(bitFieldInfo.Size);
160
161    // Insert the bits into the struct
162    // FIXME: This algorthm is only correct on X86!
163    // FIXME: THis algorthm assumes bit-fields only have byte-size elements!
164    unsigned bitsToInsert = bitFieldInfo.Size;
165    unsigned curBits = std::min(8 - (fieldOffset & 7), bitsToInsert);
166    unsigned byte = V.getLoBits(curBits).getZExtValue() << (fieldOffset & 7);
167    do {
168      llvm::Constant* byteC = llvm::ConstantInt::get(llvm::Type::Int8Ty, byte);
169      Elts[i] = llvm::ConstantExpr::getOr(Elts[i], byteC);
170      ++i;
171      V = V.lshr(curBits);
172      bitsToInsert -= curBits;
173
174      if (!bitsToInsert)
175        break;
176
177      curBits = bitsToInsert > 8 ? 8 : bitsToInsert;
178      byte = V.getLoBits(curBits).getZExtValue();
179    } while (true);
180  }
181
182  llvm::Constant *EmitStructInitialization(InitListExpr *ILE) {
183    const llvm::StructType *SType =
184        cast<llvm::StructType>(ConvertType(ILE->getType()));
185    RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl();
186    std::vector<llvm::Constant*> Elts;
187
188    // Initialize the whole structure to zero.
189    for (unsigned i = 0; i < SType->getNumElements(); ++i) {
190      const llvm::Type *FieldTy = SType->getElementType(i);
191      Elts.push_back(llvm::Constant::getNullValue(FieldTy));
192    }
193
194    // Copy initializer elements. Skip padding fields.
195    unsigned EltNo = 0;  // Element no in ILE
196    int FieldNo = 0; // Field no in RecordDecl
197    bool RewriteType = false;
198    while (EltNo < ILE->getNumInits() && FieldNo < RD->getNumMembers()) {
199      FieldDecl* curField = RD->getMember(FieldNo);
200      FieldNo++;
201      if (!curField->getIdentifier())
202        continue;
203
204      if (curField->isBitField()) {
205        InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(EltNo));
206      } else {
207        unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(curField);
208        llvm::Constant* C = Visit(ILE->getInit(EltNo));
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 *EmitUnionInitialization(InitListExpr *ILE) {
228    RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl();
229    const llvm::Type *Ty = ConvertType(ILE->getType());
230
231    // Find the field decl we're initializing, if any
232    int FieldNo = 0; // Field no in RecordDecl
233    FieldDecl* curField = 0;
234    while (FieldNo < RD->getNumMembers()) {
235      curField = RD->getMember(FieldNo);
236      FieldNo++;
237      if (curField->getIdentifier())
238        break;
239    }
240
241    if (!curField || !curField->getIdentifier() || ILE->getNumInits() == 0)
242      return llvm::Constant::getNullValue(Ty);
243
244    if (curField->isBitField()) {
245      // Create a dummy struct for bit-field insertion
246      unsigned NumElts = CGM.getTargetData().getABITypeSize(Ty) / 8;
247      llvm::Constant* NV = llvm::Constant::getNullValue(llvm::Type::Int8Ty);
248      std::vector<llvm::Constant*> Elts(NumElts, NV);
249
250      InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(0));
251      const llvm::ArrayType *RetTy =
252          llvm::ArrayType::get(NV->getType(), NumElts);
253      return llvm::ConstantArray::get(RetTy, Elts);
254    }
255
256    llvm::Constant *C = Visit(ILE->getInit(0));
257
258    // Build a struct with the union sub-element as the first member,
259    // and padded to the appropriate size
260    std::vector<llvm::Constant*> Elts;
261    std::vector<const llvm::Type*> Types;
262    Elts.push_back(C);
263    Types.push_back(C->getType());
264    unsigned CurSize = CGM.getTargetData().getTypeStoreSize(C->getType());
265    unsigned TotalSize = CGM.getTargetData().getTypeStoreSize(Ty);
266    while (CurSize < TotalSize) {
267      Elts.push_back(llvm::Constant::getNullValue(llvm::Type::Int8Ty));
268      Types.push_back(llvm::Type::Int8Ty);
269      CurSize++;
270    }
271
272    // This always generates a packed struct
273    // FIXME: Try to generate an unpacked struct when we can
274    llvm::StructType* STy = llvm::StructType::get(Types, true);
275    return llvm::ConstantStruct::get(STy, Elts);
276  }
277
278  llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) {
279    const llvm::VectorType *VType =
280        cast<llvm::VectorType>(ConvertType(ILE->getType()));
281    const llvm::Type *ElemTy = VType->getElementType();
282    std::vector<llvm::Constant*> Elts;
283    unsigned NumElements = VType->getNumElements();
284    unsigned NumInitElements = ILE->getNumInits();
285
286    unsigned NumInitableElts = std::min(NumInitElements, NumElements);
287
288    // Copy initializer elements.
289    unsigned i = 0;
290    for (; i < NumInitableElts; ++i) {
291      llvm::Constant *C = Visit(ILE->getInit(i));
292      Elts.push_back(C);
293    }
294
295    for (; i < NumElements; ++i)
296      Elts.push_back(llvm::Constant::getNullValue(ElemTy));
297
298    return llvm::ConstantVector::get(VType, Elts);
299  }
300
301  llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
302    if (ILE->getType()->isScalarType()) {
303      // We have a scalar in braces. Just use the first element.
304      if (ILE->getNumInits() > 0)
305        return Visit(ILE->getInit(0));
306
307      const llvm::Type* RetTy = CGM.getTypes().ConvertType(ILE->getType());
308      return llvm::Constant::getNullValue(RetTy);
309    }
310
311    if (ILE->getType()->isArrayType())
312      return EmitArrayInitialization(ILE);
313
314    if (ILE->getType()->isStructureType())
315      return EmitStructInitialization(ILE);
316
317    if (ILE->getType()->isUnionType())
318      return EmitUnionInitialization(ILE);
319
320    if (ILE->getType()->isVectorType())
321      return EmitVectorInitialization(ILE);
322
323    assert(0 && "Unable to handle InitListExpr");
324    // Get rid of control reaches end of void function warning.
325    // Not reached.
326    return 0;
327  }
328
329  llvm::Constant *VisitImplicitCastExpr(ImplicitCastExpr *ICExpr) {
330    Expr* SExpr = ICExpr->getSubExpr();
331    QualType SType = SExpr->getType();
332    llvm::Constant *C; // the intermediate expression
333    QualType T;        // the type of the intermediate expression
334    if (SType->isArrayType()) {
335      // Arrays decay to a pointer to the first element
336      // VLAs would require special handling, but they can't occur here
337      C = EmitLValue(SExpr);
338      llvm::Constant *Idx0 = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
339      llvm::Constant *Ops[] = {Idx0, Idx0};
340      C = llvm::ConstantExpr::getGetElementPtr(C, Ops, 2);
341      T = CGM.getContext().getArrayDecayedType(SType);
342    } else if (SType->isFunctionType()) {
343      // Function types decay to a pointer to the function
344      C = EmitLValue(SExpr);
345      T = CGM.getContext().getPointerType(SType);
346    } else {
347      C = Visit(SExpr);
348      T = SType;
349    }
350
351    // Perform the conversion; note that an implicit cast can both promote
352    // and convert an array/function
353    return EmitConversion(C, T, ICExpr->getType());
354  }
355
356  llvm::Constant *VisitStringLiteral(StringLiteral *E) {
357    const char *StrData = E->getStrData();
358    unsigned Len = E->getByteLength();
359    assert(!E->getType()->isPointerType() && "Strings are always arrays");
360
361    // Otherwise this must be a string initializing an array in a static
362    // initializer.  Don't emit it as the address of the string, emit the string
363    // data itself as an inline array.
364    const ConstantArrayType *CAT =
365      CGM.getContext().getAsConstantArrayType(E->getType());
366    assert(CAT && "String isn't pointer or array!");
367
368    std::string Str(StrData, StrData + Len);
369    // Null terminate the string before potentially truncating it.
370    // FIXME: What about wchar_t strings?
371    Str.push_back(0);
372
373    uint64_t RealLen = CAT->getSize().getZExtValue();
374    // String or grow the initializer to the required size.
375    if (RealLen != Str.size())
376      Str.resize(RealLen);
377
378    return llvm::ConstantArray::get(Str, false);
379  }
380
381  llvm::Constant *VisitDeclRefExpr(DeclRefExpr *E) {
382    const ValueDecl *Decl = E->getDecl();
383    if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(Decl))
384      return llvm::ConstantInt::get(EC->getInitVal());
385    assert(0 && "Unsupported decl ref type!");
386    return 0;
387  }
388
389  llvm::Constant *VisitSizeOfAlignOfTypeExpr(const SizeOfAlignOfTypeExpr *E) {
390    return EmitSizeAlignOf(E->getArgumentType(), E->getType(), E->isSizeOf());
391  }
392
393  // Unary operators
394  llvm::Constant *VisitUnaryPlus(const UnaryOperator *E) {
395    return Visit(E->getSubExpr());
396  }
397  llvm::Constant *VisitUnaryMinus(const UnaryOperator *E) {
398    return llvm::ConstantExpr::getNeg(Visit(E->getSubExpr()));
399  }
400  llvm::Constant *VisitUnaryNot(const UnaryOperator *E) {
401    return llvm::ConstantExpr::getNot(Visit(E->getSubExpr()));
402  }
403  llvm::Constant *VisitUnaryLNot(const UnaryOperator *E) {
404    llvm::Constant *SubExpr = Visit(E->getSubExpr());
405
406    if (E->getSubExpr()->getType()->isRealFloatingType()) {
407      // Compare against 0.0 for fp scalars.
408      llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType());
409      SubExpr = llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UEQ, SubExpr,
410                                            Zero);
411    } else {
412      assert((E->getSubExpr()->getType()->isIntegerType() ||
413              E->getSubExpr()->getType()->isPointerType()) &&
414             "Unknown scalar type to convert");
415      // Compare against an integer or pointer null.
416      llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType());
417      SubExpr = llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_EQ, SubExpr,
418                                            Zero);
419    }
420
421    return llvm::ConstantExpr::getZExt(SubExpr, ConvertType(E->getType()));
422  }
423  llvm::Constant *VisitUnarySizeOf(const UnaryOperator *E) {
424    return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), true);
425  }
426  llvm::Constant *VisitUnaryAlignOf(const UnaryOperator *E) {
427    return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), false);
428  }
429  llvm::Constant *VisitUnaryAddrOf(const UnaryOperator *E) {
430    return EmitLValue(E->getSubExpr());
431  }
432  llvm::Constant *VisitUnaryOffsetOf(const UnaryOperator *E) {
433    int64_t Val = E->evaluateOffsetOf(CGM.getContext());
434
435    assert(E->getType()->isIntegerType() && "Result type must be an integer!");
436
437    uint32_t ResultWidth =
438      static_cast<uint32_t>(CGM.getContext().getTypeSize(E->getType()));
439    return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
440  }
441
442  llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) {
443    return Visit(E->getSubExpr());
444  }
445
446  // Binary operators
447  llvm::Constant *VisitBinOr(const BinaryOperator *E) {
448    llvm::Constant *LHS = Visit(E->getLHS());
449    llvm::Constant *RHS = Visit(E->getRHS());
450
451    return llvm::ConstantExpr::getOr(LHS, RHS);
452  }
453  llvm::Constant *VisitBinSub(const BinaryOperator *E) {
454    llvm::Constant *LHS = Visit(E->getLHS());
455    llvm::Constant *RHS = Visit(E->getRHS());
456
457    if (!isa<llvm::PointerType>(RHS->getType())) {
458      // pointer - int
459      if (isa<llvm::PointerType>(LHS->getType())) {
460        llvm::Constant *Idx = llvm::ConstantExpr::getNeg(RHS);
461
462        return llvm::ConstantExpr::getGetElementPtr(LHS, &Idx, 1);
463      }
464
465      // int - int
466      return llvm::ConstantExpr::getSub(LHS, RHS);
467    }
468
469    assert(isa<llvm::PointerType>(LHS->getType()));
470
471    const llvm::Type *ResultType = ConvertType(E->getType());
472    const QualType Type = E->getLHS()->getType();
473    const QualType ElementType = Type->getAsPointerType()->getPointeeType();
474
475    LHS = llvm::ConstantExpr::getPtrToInt(LHS, ResultType);
476    RHS = llvm::ConstantExpr::getPtrToInt(RHS, ResultType);
477
478    llvm::Constant *sub = llvm::ConstantExpr::getSub(LHS, RHS);
479    llvm::Constant *size = EmitSizeAlignOf(ElementType, E->getType(), true);
480    return llvm::ConstantExpr::getSDiv(sub, size);
481  }
482
483  llvm::Constant *VisitBinShl(const BinaryOperator *E) {
484    llvm::Constant *LHS = Visit(E->getLHS());
485    llvm::Constant *RHS = Visit(E->getRHS());
486
487    // LLVM requires the LHS and RHS to be the same type: promote or truncate the
488    // RHS to the same size as the LHS.
489    if (LHS->getType() != RHS->getType())
490      RHS = llvm::ConstantExpr::getIntegerCast(RHS, LHS->getType(), false);
491
492    return llvm::ConstantExpr::getShl(LHS, RHS);
493  }
494
495  llvm::Constant *VisitBinMul(const BinaryOperator *E) {
496    llvm::Constant *LHS = Visit(E->getLHS());
497    llvm::Constant *RHS = Visit(E->getRHS());
498
499    return llvm::ConstantExpr::getMul(LHS, RHS);
500  }
501
502  llvm::Constant *VisitBinDiv(const BinaryOperator *E) {
503    llvm::Constant *LHS = Visit(E->getLHS());
504    llvm::Constant *RHS = Visit(E->getRHS());
505
506    if (LHS->getType()->isFPOrFPVector())
507      return llvm::ConstantExpr::getFDiv(LHS, RHS);
508    else if (E->getType()->isUnsignedIntegerType())
509      return llvm::ConstantExpr::getUDiv(LHS, RHS);
510    else
511      return llvm::ConstantExpr::getSDiv(LHS, RHS);
512  }
513
514  llvm::Constant *VisitBinAdd(const BinaryOperator *E) {
515    llvm::Constant *LHS = Visit(E->getLHS());
516    llvm::Constant *RHS = Visit(E->getRHS());
517
518    if (!E->getType()->isPointerType())
519      return llvm::ConstantExpr::getAdd(LHS, RHS);
520
521    llvm::Constant *Ptr, *Idx;
522    if (isa<llvm::PointerType>(LHS->getType())) { // pointer + int
523      Ptr = LHS;
524      Idx = RHS;
525    } else { // int + pointer
526      Ptr = RHS;
527      Idx = LHS;
528    }
529
530    return llvm::ConstantExpr::getGetElementPtr(Ptr, &Idx, 1);
531  }
532
533  llvm::Constant *VisitBinAnd(const BinaryOperator *E) {
534    llvm::Constant *LHS = Visit(E->getLHS());
535    llvm::Constant *RHS = Visit(E->getRHS());
536
537    return llvm::ConstantExpr::getAnd(LHS, RHS);
538  }
539
540  llvm::Constant *EmitCmp(const BinaryOperator *E,
541                          llvm::CmpInst::Predicate SignedPred,
542                          llvm::CmpInst::Predicate UnsignedPred,
543                          llvm::CmpInst::Predicate FloatPred) {
544    llvm::Constant *LHS = Visit(E->getLHS());
545    llvm::Constant *RHS = Visit(E->getRHS());
546    llvm::Constant *Result;
547    if (LHS->getType()->isInteger() ||
548        isa<llvm::PointerType>(LHS->getType())) {
549      if (E->getLHS()->getType()->isSignedIntegerType())
550        Result = llvm::ConstantExpr::getICmp(SignedPred, LHS, RHS);
551      else
552        Result = llvm::ConstantExpr::getICmp(UnsignedPred, LHS, RHS);
553    } else if (LHS->getType()->isFloatingPoint()) {
554      Result = llvm::ConstantExpr::getFCmp(FloatPred, LHS, RHS);
555    } else {
556      CGM.WarnUnsupported(E, "constant expression");
557      Result = llvm::ConstantInt::getFalse();
558    }
559
560    const llvm::Type* ResultType = ConvertType(E->getType());
561    return llvm::ConstantExpr::getZExtOrBitCast(Result, ResultType);
562  }
563
564  llvm::Constant *VisitBinNE(const BinaryOperator *E) {
565    return EmitCmp(E, llvm::CmpInst::ICMP_NE, llvm::CmpInst::ICMP_NE,
566                   llvm::CmpInst::FCMP_ONE);
567  }
568
569  llvm::Constant *VisitBinEQ(const BinaryOperator *E) {
570    return EmitCmp(E, llvm::CmpInst::ICMP_EQ, llvm::CmpInst::ICMP_EQ,
571                   llvm::CmpInst::FCMP_OEQ);
572  }
573
574  llvm::Constant *VisitBinLT(const BinaryOperator *E) {
575    return EmitCmp(E, llvm::CmpInst::ICMP_SLT, llvm::CmpInst::ICMP_ULT,
576                   llvm::CmpInst::FCMP_OLT);
577  }
578
579  llvm::Constant *VisitBinLE(const BinaryOperator *E) {
580    return EmitCmp(E, llvm::CmpInst::ICMP_SLE, llvm::CmpInst::ICMP_ULE,
581                   llvm::CmpInst::FCMP_OLE);
582  }
583
584  llvm::Constant *VisitBinGT(const BinaryOperator *E) {
585    return EmitCmp(E, llvm::CmpInst::ICMP_SGT, llvm::CmpInst::ICMP_UGT,
586                   llvm::CmpInst::FCMP_OGT);
587  }
588
589  llvm::Constant *VisitBinGE(const BinaryOperator *E) {
590    return EmitCmp(E, llvm::CmpInst::ICMP_SGE, llvm::CmpInst::ICMP_SGE,
591                   llvm::CmpInst::FCMP_OGE);
592  }
593
594  llvm::Constant *VisitConditionalOperator(const ConditionalOperator *E) {
595    llvm::Constant *Cond = Visit(E->getCond());
596    llvm::Constant *CondVal = EmitConversionToBool(Cond, E->getType());
597    llvm::ConstantInt *CondValInt = dyn_cast<llvm::ConstantInt>(CondVal);
598    if (!CondValInt) {
599      CGM.WarnUnsupported(E, "constant expression");
600      return llvm::Constant::getNullValue(ConvertType(E->getType()));
601    }
602    if (CondValInt->isOne()) {
603      if (E->getLHS())
604        return Visit(E->getLHS());
605      return Cond;
606    }
607
608    return Visit(E->getRHS());
609  }
610
611  // Utility methods
612  const llvm::Type *ConvertType(QualType T) {
613    return CGM.getTypes().ConvertType(T);
614  }
615
616  llvm::Constant *EmitConversionToBool(llvm::Constant *Src, QualType SrcType) {
617    assert(SrcType->isCanonical() && "EmitConversion strips typedefs");
618
619    if (SrcType->isRealFloatingType()) {
620      // Compare against 0.0 for fp scalars.
621      llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType());
622      return llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UNE, Src, Zero);
623    }
624
625    assert((SrcType->isIntegerType() || SrcType->isPointerType()) &&
626           "Unknown scalar type to convert");
627
628    // Compare against an integer or pointer null.
629    llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType());
630    return llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_NE, Src, Zero);
631  }
632
633  llvm::Constant *EmitConversion(llvm::Constant *Src, QualType SrcType,
634                                 QualType DstType) {
635    SrcType = CGM.getContext().getCanonicalType(SrcType);
636    DstType = CGM.getContext().getCanonicalType(DstType);
637    if (SrcType == DstType) return Src;
638
639    // Handle conversions to bool first, they are special: comparisons against 0.
640    if (DstType->isBooleanType())
641      return EmitConversionToBool(Src, SrcType);
642
643    const llvm::Type *DstTy = ConvertType(DstType);
644
645    // Ignore conversions like int -> uint.
646    if (Src->getType() == DstTy)
647      return Src;
648
649    // Handle pointer conversions next: pointers can only be converted to/from
650    // other pointers and integers.
651    if (isa<llvm::PointerType>(DstTy)) {
652      // The source value may be an integer, or a pointer.
653      if (isa<llvm::PointerType>(Src->getType()))
654        return llvm::ConstantExpr::getBitCast(Src, DstTy);
655      assert(SrcType->isIntegerType() &&"Not ptr->ptr or int->ptr conversion?");
656      return llvm::ConstantExpr::getIntToPtr(Src, DstTy);
657    }
658
659    if (isa<llvm::PointerType>(Src->getType())) {
660      // Must be an ptr to int cast.
661      assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?");
662      return llvm::ConstantExpr::getPtrToInt(Src, DstTy);
663    }
664
665    // A scalar source can be splatted to a vector of the same element type
666    if (isa<llvm::VectorType>(DstTy) && !isa<VectorType>(SrcType)) {
667      const llvm::VectorType *VT = cast<llvm::VectorType>(DstTy);
668      assert((VT->getElementType() == Src->getType()) &&
669             "Vector element type must match scalar type to splat.");
670      unsigned NumElements = DstType->getAsVectorType()->getNumElements();
671      llvm::SmallVector<llvm::Constant*, 16> Elements;
672      for (unsigned i = 0; i < NumElements; i++)
673        Elements.push_back(Src);
674
675      return llvm::ConstantVector::get(&Elements[0], NumElements);
676    }
677
678    if (isa<llvm::VectorType>(Src->getType()) ||
679        isa<llvm::VectorType>(DstTy)) {
680      return llvm::ConstantExpr::getBitCast(Src, DstTy);
681    }
682
683    // Finally, we have the arithmetic types: real int/float.
684    if (isa<llvm::IntegerType>(Src->getType())) {
685      bool InputSigned = SrcType->isSignedIntegerType();
686      if (isa<llvm::IntegerType>(DstTy))
687        return llvm::ConstantExpr::getIntegerCast(Src, DstTy, InputSigned);
688      else if (InputSigned)
689        return llvm::ConstantExpr::getSIToFP(Src, DstTy);
690      else
691        return llvm::ConstantExpr::getUIToFP(Src, DstTy);
692    }
693
694    assert(Src->getType()->isFloatingPoint() && "Unknown real conversion");
695    if (isa<llvm::IntegerType>(DstTy)) {
696      if (DstType->isSignedIntegerType())
697        return llvm::ConstantExpr::getFPToSI(Src, DstTy);
698      else
699        return llvm::ConstantExpr::getFPToUI(Src, DstTy);
700    }
701
702    assert(DstTy->isFloatingPoint() && "Unknown real conversion");
703    if (DstTy->getTypeID() < Src->getType()->getTypeID())
704      return llvm::ConstantExpr::getFPTrunc(Src, DstTy);
705    else
706      return llvm::ConstantExpr::getFPExtend(Src, DstTy);
707  }
708
709  llvm::Constant *EmitSizeAlignOf(QualType TypeToSize,
710                                  QualType RetType, bool isSizeOf) {
711    std::pair<uint64_t, unsigned> Info =
712      CGM.getContext().getTypeInfo(TypeToSize);
713
714    uint64_t Val = isSizeOf ? Info.first : Info.second;
715    Val /= 8;  // Return size in bytes, not bits.
716
717    assert(RetType->isIntegerType() && "Result type must be an integer!");
718
719    uint32_t ResultWidth =
720      static_cast<uint32_t>(CGM.getContext().getTypeSize(RetType));
721    return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
722  }
723
724  llvm::Constant *EmitLValue(Expr *E) {
725    switch (E->getStmtClass()) {
726    default: break;
727    case Expr::ParenExprClass:
728      // Elide parenthesis
729      return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
730    case Expr::CompoundLiteralExprClass: {
731      // Note that due to the nature of compound literals, this is guaranteed
732      // to be the only use of the variable, so we just generate it here.
733      CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
734      llvm::Constant* C = Visit(CLE->getInitializer());
735      C = new llvm::GlobalVariable(C->getType(),E->getType().isConstQualified(),
736                                   llvm::GlobalValue::InternalLinkage,
737                                   C, ".compoundliteral", &CGM.getModule());
738      return C;
739    }
740    case Expr::DeclRefExprClass: {
741      ValueDecl *Decl = cast<DeclRefExpr>(E)->getDecl();
742      if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
743        return CGM.GetAddrOfFunction(FD);
744      if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) {
745        if (VD->isFileVarDecl())
746          return CGM.GetAddrOfGlobalVar(VD);
747        else if (VD->isBlockVarDecl()) {
748          assert(CGF && "Can't access static local vars without CGF");
749          return CGF->GetAddrOfStaticLocalVar(VD);
750        }
751      }
752      break;
753    }
754    case Expr::MemberExprClass: {
755      MemberExpr* ME = cast<MemberExpr>(E);
756      llvm::Constant *Base;
757      if (ME->isArrow())
758        Base = Visit(ME->getBase());
759      else
760        Base = EmitLValue(ME->getBase());
761
762      unsigned FieldNumber = CGM.getTypes().getLLVMFieldNo(ME->getMemberDecl());
763      llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
764      llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty,
765                                                   FieldNumber);
766      llvm::Value *Ops[] = {Zero, Idx};
767      return llvm::ConstantExpr::getGetElementPtr(Base, Ops, 2);
768    }
769    case Expr::ArraySubscriptExprClass: {
770      ArraySubscriptExpr* ASExpr = cast<ArraySubscriptExpr>(E);
771      llvm::Constant *Base = Visit(ASExpr->getBase());
772      llvm::Constant *Index = Visit(ASExpr->getIdx());
773      assert(!ASExpr->getBase()->getType()->isVectorType() &&
774             "Taking the address of a vector component is illegal!");
775      return llvm::ConstantExpr::getGetElementPtr(Base, &Index, 1);
776    }
777    case Expr::StringLiteralClass: {
778      StringLiteral *String = cast<StringLiteral>(E);
779      assert(!String->isWide() && "Cannot codegen wide strings yet");
780      const char *StrData = String->getStrData();
781      unsigned Len = String->getByteLength();
782
783      return CGM.GetAddrOfConstantString(std::string(StrData, StrData + Len));
784    }
785    case Expr::UnaryOperatorClass: {
786      UnaryOperator *Exp = cast<UnaryOperator>(E);
787      switch (Exp->getOpcode()) {
788      default: break;
789      case UnaryOperator::Extension:
790        // Extension is just a wrapper for expressions
791        return EmitLValue(Exp->getSubExpr());
792      case UnaryOperator::Real:
793      case UnaryOperator::Imag: {
794        // The address of __real or __imag is just a GEP off the address
795        // of the internal expression
796        llvm::Constant* C = EmitLValue(Exp->getSubExpr());
797        llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
798        llvm::Constant *Idx  = llvm::ConstantInt::get(llvm::Type::Int32Ty,
799                                       Exp->getOpcode() == UnaryOperator::Imag);
800        llvm::Value *Ops[] = {Zero, Idx};
801        return llvm::ConstantExpr::getGetElementPtr(C, Ops, 2);
802      }
803      case UnaryOperator::Deref:
804        // The address of a deref is just the value of the expression
805        return Visit(Exp->getSubExpr());
806      }
807      break;
808    }
809    }
810    CGM.WarnUnsupported(E, "constant l-value expression");
811    llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
812    return llvm::UndefValue::get(Ty);
813  }
814
815};
816
817}  // end anonymous namespace.
818
819
820llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
821                                                CodeGenFunction *CGF) {
822  QualType type = Context.getCanonicalType(E->getType());
823
824  if (type->isIntegerType()) {
825    llvm::APSInt Value(static_cast<uint32_t>(Context.getTypeSize(type)));
826    if (E->isIntegerConstantExpr(Value, Context)) {
827      return llvm::ConstantInt::get(Value);
828    }
829  }
830
831  llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
832  if (C->getType() == llvm::Type::Int1Ty) {
833    const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
834    C = llvm::ConstantExpr::getZExt(C, BoolTy);
835  }
836  return C;
837}
838