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