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