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