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