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(0 && "Unhandled bin sub case!");
452     return 0;
453   }
454 
455   llvm::Constant *VisitBinShl(const BinaryOperator *E) {
456     llvm::Constant *LHS = Visit(E->getLHS());
457     llvm::Constant *RHS = Visit(E->getRHS());
458 
459     // LLVM requires the LHS and RHS to be the same type: promote or truncate the
460     // RHS to the same size as the LHS.
461     if (LHS->getType() != RHS->getType())
462       RHS = llvm::ConstantExpr::getIntegerCast(RHS, LHS->getType(), false);
463 
464     return llvm::ConstantExpr::getShl(LHS, RHS);
465   }
466 
467   llvm::Constant *VisitBinMul(const BinaryOperator *E) {
468     llvm::Constant *LHS = Visit(E->getLHS());
469     llvm::Constant *RHS = Visit(E->getRHS());
470 
471     return llvm::ConstantExpr::getMul(LHS, RHS);
472   }
473 
474   llvm::Constant *VisitBinDiv(const BinaryOperator *E) {
475     llvm::Constant *LHS = Visit(E->getLHS());
476     llvm::Constant *RHS = Visit(E->getRHS());
477 
478     if (LHS->getType()->isFPOrFPVector())
479       return llvm::ConstantExpr::getFDiv(LHS, RHS);
480     else if (E->getType()->isUnsignedIntegerType())
481       return llvm::ConstantExpr::getUDiv(LHS, RHS);
482     else
483       return llvm::ConstantExpr::getSDiv(LHS, RHS);
484   }
485 
486   llvm::Constant *VisitBinAdd(const BinaryOperator *E) {
487     llvm::Constant *LHS = Visit(E->getLHS());
488     llvm::Constant *RHS = Visit(E->getRHS());
489 
490     if (!E->getType()->isPointerType())
491       return llvm::ConstantExpr::getAdd(LHS, RHS);
492 
493     llvm::Constant *Ptr, *Idx;
494     if (isa<llvm::PointerType>(LHS->getType())) { // pointer + int
495       Ptr = LHS;
496       Idx = RHS;
497     } else { // int + pointer
498       Ptr = RHS;
499       Idx = LHS;
500     }
501 
502     return llvm::ConstantExpr::getGetElementPtr(Ptr, &Idx, 1);
503   }
504 
505   llvm::Constant *VisitBinAnd(const BinaryOperator *E) {
506     llvm::Constant *LHS = Visit(E->getLHS());
507     llvm::Constant *RHS = Visit(E->getRHS());
508 
509     return llvm::ConstantExpr::getAnd(LHS, RHS);
510   }
511 
512   llvm::Constant *EmitCmp(const BinaryOperator *E,
513                           llvm::CmpInst::Predicate SignedPred,
514                           llvm::CmpInst::Predicate UnsignedPred,
515                           llvm::CmpInst::Predicate FloatPred) {
516     llvm::Constant *LHS = Visit(E->getLHS());
517     llvm::Constant *RHS = Visit(E->getRHS());
518     llvm::Constant *Result;
519     if (LHS->getType()->isInteger() ||
520         isa<llvm::PointerType>(LHS->getType())) {
521       if (E->getLHS()->getType()->isSignedIntegerType())
522         Result = llvm::ConstantExpr::getICmp(SignedPred, LHS, RHS);
523       else
524         Result = llvm::ConstantExpr::getICmp(UnsignedPred, LHS, RHS);
525     } else if (LHS->getType()->isFloatingPoint()) {
526       Result = llvm::ConstantExpr::getFCmp(FloatPred, LHS, RHS);
527     } else {
528       CGM.WarnUnsupported(E, "constant expression");
529       Result = llvm::ConstantInt::getFalse();
530     }
531 
532     const llvm::Type* ResultType = ConvertType(E->getType());
533     return llvm::ConstantExpr::getZExtOrBitCast(Result, ResultType);
534   }
535 
536   llvm::Constant *VisitBinNE(const BinaryOperator *E) {
537     return EmitCmp(E, llvm::CmpInst::ICMP_NE, llvm::CmpInst::ICMP_NE,
538                    llvm::CmpInst::FCMP_ONE);
539   }
540 
541   llvm::Constant *VisitBinEQ(const BinaryOperator *E) {
542     return EmitCmp(E, llvm::CmpInst::ICMP_EQ, llvm::CmpInst::ICMP_EQ,
543                    llvm::CmpInst::FCMP_OEQ);
544   }
545 
546   llvm::Constant *VisitBinLT(const BinaryOperator *E) {
547     return EmitCmp(E, llvm::CmpInst::ICMP_SLT, llvm::CmpInst::ICMP_ULT,
548                    llvm::CmpInst::FCMP_OLT);
549   }
550 
551   llvm::Constant *VisitBinLE(const BinaryOperator *E) {
552     return EmitCmp(E, llvm::CmpInst::ICMP_SLE, llvm::CmpInst::ICMP_ULE,
553                    llvm::CmpInst::FCMP_OLE);
554   }
555 
556   llvm::Constant *VisitBinGT(const BinaryOperator *E) {
557     return EmitCmp(E, llvm::CmpInst::ICMP_SGT, llvm::CmpInst::ICMP_UGT,
558                    llvm::CmpInst::FCMP_OGT);
559   }
560 
561   llvm::Constant *VisitBinGE(const BinaryOperator *E) {
562     return EmitCmp(E, llvm::CmpInst::ICMP_SGE, llvm::CmpInst::ICMP_SGE,
563                    llvm::CmpInst::FCMP_OGE);
564   }
565 
566   llvm::Constant *VisitConditionalOperator(const ConditionalOperator *E) {
567     llvm::Constant *Cond = Visit(E->getCond());
568     llvm::Constant *CondVal = EmitConversionToBool(Cond, E->getType());
569     llvm::ConstantInt *CondValInt = dyn_cast<llvm::ConstantInt>(CondVal);
570     if (!CondValInt) {
571       CGM.WarnUnsupported(E, "constant expression");
572       return llvm::Constant::getNullValue(ConvertType(E->getType()));
573     }
574     if (CondValInt->isOne()) {
575       if (E->getLHS())
576         return Visit(E->getLHS());
577       return Cond;
578     }
579 
580     return Visit(E->getRHS());
581   }
582 
583   // Utility methods
584   const llvm::Type *ConvertType(QualType T) {
585     return CGM.getTypes().ConvertType(T);
586   }
587 
588   llvm::Constant *EmitConversionToBool(llvm::Constant *Src, QualType SrcType) {
589     assert(SrcType->isCanonical() && "EmitConversion strips typedefs");
590 
591     if (SrcType->isRealFloatingType()) {
592       // Compare against 0.0 for fp scalars.
593       llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType());
594       return llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UNE, Src, Zero);
595     }
596 
597     assert((SrcType->isIntegerType() || SrcType->isPointerType()) &&
598            "Unknown scalar type to convert");
599 
600     // Compare against an integer or pointer null.
601     llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType());
602     return llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_NE, Src, Zero);
603   }
604 
605   llvm::Constant *EmitConversion(llvm::Constant *Src, QualType SrcType,
606                                  QualType DstType) {
607     SrcType = SrcType.getCanonicalType();
608     DstType = DstType.getCanonicalType();
609     if (SrcType == DstType) return Src;
610 
611     // Handle conversions to bool first, they are special: comparisons against 0.
612     if (DstType->isBooleanType())
613       return EmitConversionToBool(Src, SrcType);
614 
615     const llvm::Type *DstTy = ConvertType(DstType);
616 
617     // Ignore conversions like int -> uint.
618     if (Src->getType() == DstTy)
619       return Src;
620 
621     // Handle pointer conversions next: pointers can only be converted to/from
622     // other pointers and integers.
623     if (isa<PointerType>(DstType)) {
624       // The source value may be an integer, or a pointer.
625       if (isa<llvm::PointerType>(Src->getType()))
626         return llvm::ConstantExpr::getBitCast(Src, DstTy);
627       assert(SrcType->isIntegerType() &&"Not ptr->ptr or int->ptr conversion?");
628       return llvm::ConstantExpr::getIntToPtr(Src, DstTy);
629     }
630 
631     if (isa<PointerType>(SrcType)) {
632       // Must be an ptr to int cast.
633       assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?");
634       return llvm::ConstantExpr::getPtrToInt(Src, DstTy);
635     }
636 
637     // A scalar source can be splatted to a vector of the same element type
638     if (isa<llvm::VectorType>(DstTy) && !isa<VectorType>(SrcType)) {
639       const llvm::VectorType *VT = cast<llvm::VectorType>(DstTy);
640       assert((VT->getElementType() == Src->getType()) &&
641              "Vector element type must match scalar type to splat.");
642       unsigned NumElements = DstType->getAsVectorType()->getNumElements();
643       llvm::SmallVector<llvm::Constant*, 16> Elements;
644       for (unsigned i = 0; i < NumElements; i++)
645         Elements.push_back(Src);
646 
647       return llvm::ConstantVector::get(&Elements[0], NumElements);
648     }
649 
650     if (isa<llvm::VectorType>(Src->getType()) ||
651         isa<llvm::VectorType>(DstTy)) {
652       return llvm::ConstantExpr::getBitCast(Src, DstTy);
653     }
654 
655     // Finally, we have the arithmetic types: real int/float.
656     if (isa<llvm::IntegerType>(Src->getType())) {
657       bool InputSigned = SrcType->isSignedIntegerType();
658       if (isa<llvm::IntegerType>(DstTy))
659         return llvm::ConstantExpr::getIntegerCast(Src, DstTy, InputSigned);
660       else if (InputSigned)
661         return llvm::ConstantExpr::getSIToFP(Src, DstTy);
662       else
663         return llvm::ConstantExpr::getUIToFP(Src, DstTy);
664     }
665 
666     assert(Src->getType()->isFloatingPoint() && "Unknown real conversion");
667     if (isa<llvm::IntegerType>(DstTy)) {
668       if (DstType->isSignedIntegerType())
669         return llvm::ConstantExpr::getFPToSI(Src, DstTy);
670       else
671         return llvm::ConstantExpr::getFPToUI(Src, DstTy);
672     }
673 
674     assert(DstTy->isFloatingPoint() && "Unknown real conversion");
675     if (DstTy->getTypeID() < Src->getType()->getTypeID())
676       return llvm::ConstantExpr::getFPTrunc(Src, DstTy);
677     else
678       return llvm::ConstantExpr::getFPExtend(Src, DstTy);
679   }
680 
681   llvm::Constant *EmitSizeAlignOf(QualType TypeToSize,
682                                   QualType RetType, bool isSizeOf) {
683     std::pair<uint64_t, unsigned> Info =
684       CGM.getContext().getTypeInfo(TypeToSize);
685 
686     uint64_t Val = isSizeOf ? Info.first : Info.second;
687     Val /= 8;  // Return size in bytes, not bits.
688 
689     assert(RetType->isIntegerType() && "Result type must be an integer!");
690 
691     uint32_t ResultWidth =
692       static_cast<uint32_t>(CGM.getContext().getTypeSize(RetType));
693     return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
694   }
695 
696   llvm::Constant *EmitLValue(Expr *E) {
697     switch (E->getStmtClass()) {
698     default: break;
699     case Expr::ParenExprClass:
700       // Elide parenthesis
701       return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
702     case Expr::CompoundLiteralExprClass: {
703       // Note that due to the nature of compound literals, this is guaranteed
704       // to be the only use of the variable, so we just generate it here.
705       CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
706       llvm::Constant* C = Visit(CLE->getInitializer());
707       C = new llvm::GlobalVariable(C->getType(),E->getType().isConstQualified(),
708                                    llvm::GlobalValue::InternalLinkage,
709                                    C, ".compoundliteral", &CGM.getModule());
710       return C;
711     }
712     case Expr::DeclRefExprClass: {
713       ValueDecl *Decl = cast<DeclRefExpr>(E)->getDecl();
714       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
715         return CGM.GetAddrOfFunctionDecl(FD, false);
716       if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) {
717         if (VD->isFileVarDecl())
718           return CGM.GetAddrOfGlobalVar(VD, false);
719         else if (VD->isBlockVarDecl()) {
720           assert(CGF && "Can't access static local vars without CGF");
721           return CGF->GetAddrOfStaticLocalVar(VD);
722         }
723       }
724       break;
725     }
726     case Expr::MemberExprClass: {
727       MemberExpr* ME = cast<MemberExpr>(E);
728       llvm::Constant *Base;
729       if (ME->isArrow())
730         Base = Visit(ME->getBase());
731       else
732         Base = EmitLValue(ME->getBase());
733 
734       unsigned FieldNumber = CGM.getTypes().getLLVMFieldNo(ME->getMemberDecl());
735       llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
736       llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty,
737                                                    FieldNumber);
738       llvm::Value *Ops[] = {Zero, Idx};
739       return llvm::ConstantExpr::getGetElementPtr(Base, Ops, 2);
740     }
741     case Expr::ArraySubscriptExprClass: {
742       ArraySubscriptExpr* ASExpr = cast<ArraySubscriptExpr>(E);
743       llvm::Constant *Base = Visit(ASExpr->getBase());
744       llvm::Constant *Index = Visit(ASExpr->getIdx());
745       assert(!ASExpr->getBase()->getType()->isVectorType() &&
746              "Taking the address of a vector component is illegal!");
747       return llvm::ConstantExpr::getGetElementPtr(Base, &Index, 1);
748     }
749     case Expr::StringLiteralClass: {
750       StringLiteral *String = cast<StringLiteral>(E);
751       assert(!String->isWide() && "Cannot codegen wide strings yet");
752       const char *StrData = String->getStrData();
753       unsigned Len = String->getByteLength();
754 
755       return CGM.GetAddrOfConstantString(std::string(StrData, StrData + Len));
756     }
757     case Expr::UnaryOperatorClass: {
758       UnaryOperator *Exp = cast<UnaryOperator>(E);
759       switch (Exp->getOpcode()) {
760       default: break;
761       case UnaryOperator::Extension:
762         // Extension is just a wrapper for expressions
763         return EmitLValue(Exp->getSubExpr());
764       case UnaryOperator::Real:
765       case UnaryOperator::Imag: {
766         // The address of __real or __imag is just a GEP off the address
767         // of the internal expression
768         llvm::Constant* C = EmitLValue(Exp->getSubExpr());
769         llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
770         llvm::Constant *Idx  = llvm::ConstantInt::get(llvm::Type::Int32Ty,
771                                        Exp->getOpcode() == UnaryOperator::Imag);
772         llvm::Value *Ops[] = {Zero, Idx};
773         return llvm::ConstantExpr::getGetElementPtr(C, Ops, 2);
774       }
775       case UnaryOperator::Deref:
776         // The address of a deref is just the value of the expression
777         return Visit(Exp->getSubExpr());
778       }
779       break;
780     }
781     }
782     CGM.WarnUnsupported(E, "constant l-value expression");
783     llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
784     return llvm::UndefValue::get(Ty);
785   }
786 
787 };
788 
789 }  // end anonymous namespace.
790 
791 
792 llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
793                                                 CodeGenFunction *CGF)
794 {
795   QualType type = E->getType().getCanonicalType();
796 
797   if (type->isIntegerType()) {
798     llvm::APSInt Value(static_cast<uint32_t>(Context.getTypeSize(type)));
799     if (E->isIntegerConstantExpr(Value, Context)) {
800       return llvm::ConstantInt::get(Value);
801     }
802   }
803 
804   return ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
805 }
806