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