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/APValue.h"
18 #include "clang/AST/ASTContext.h"
19 #include "clang/AST/StmtVisitor.h"
20 #include "llvm/Constants.h"
21 #include "llvm/Function.h"
22 #include "llvm/GlobalVariable.h"
23 #include "llvm/Support/Compiler.h"
24 #include "llvm/Target/TargetData.h"
25 using namespace clang;
26 using namespace CodeGen;
27 
28 namespace  {
29 class VISIBILITY_HIDDEN ConstExprEmitter :
30   public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
31   CodeGenModule &CGM;
32   CodeGenFunction *CGF;
33 public:
34   ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf)
35     : CGM(cgm), CGF(cgf) {
36   }
37 
38   //===--------------------------------------------------------------------===//
39   //                            Visitor Methods
40   //===--------------------------------------------------------------------===//
41 
42   llvm::Constant *VisitStmt(Stmt *S) {
43     return 0;
44   }
45 
46   llvm::Constant *VisitParenExpr(ParenExpr *PE) {
47     return Visit(PE->getSubExpr());
48   }
49 
50   llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
51     return Visit(E->getInitializer());
52   }
53 
54   llvm::Constant *VisitCastExpr(CastExpr* E) {
55     // GCC cast to union extension
56     if (E->getType()->isUnionType()) {
57       const llvm::Type *Ty = ConvertType(E->getType());
58       return EmitUnion(CGM.EmitConstantExpr(E->getSubExpr(), CGF), Ty);
59     }
60     if (CGM.getContext().getCanonicalType(E->getSubExpr()->getType()) ==
61         CGM.getContext().getCanonicalType(E->getType())) {
62       return Visit(E->getSubExpr());
63     }
64     return 0;
65   }
66 
67   llvm::Constant *VisitCXXDefaultArgExpr(CXXDefaultArgExpr *DAE) {
68     return Visit(DAE->getExpr());
69   }
70 
71   llvm::Constant *EmitArrayInitialization(InitListExpr *ILE) {
72     std::vector<llvm::Constant*> Elts;
73     const llvm::ArrayType *AType =
74         cast<llvm::ArrayType>(ConvertType(ILE->getType()));
75     unsigned NumInitElements = ILE->getNumInits();
76     // FIXME: Check for wide strings
77     // FIXME: Check for NumInitElements exactly equal to 1??
78     if (NumInitElements > 0 &&
79         (isa<StringLiteral>(ILE->getInit(0)) ||
80          isa<ObjCEncodeExpr>(ILE->getInit(0))) &&
81         ILE->getType()->getArrayElementTypeNoTypeQual()->isCharType())
82       return Visit(ILE->getInit(0));
83     const llvm::Type *ElemTy = AType->getElementType();
84     unsigned NumElements = AType->getNumElements();
85 
86     // Initialising an array requires us to automatically
87     // initialise any elements that have not been initialised explicitly
88     unsigned NumInitableElts = std::min(NumInitElements, NumElements);
89 
90     // Copy initializer elements.
91     unsigned i = 0;
92     bool RewriteType = false;
93     for (; i < NumInitableElts; ++i) {
94       llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF);
95       if (!C)
96         return 0;
97       RewriteType |= (C->getType() != ElemTy);
98       Elts.push_back(C);
99     }
100 
101     // Initialize remaining array elements.
102     for (; i < NumElements; ++i)
103       Elts.push_back(llvm::Constant::getNullValue(ElemTy));
104 
105     if (RewriteType) {
106       // FIXME: Try to avoid packing the array
107       std::vector<const llvm::Type*> Types;
108       for (unsigned i = 0; i < Elts.size(); ++i)
109         Types.push_back(Elts[i]->getType());
110       const llvm::StructType *SType = llvm::StructType::get(Types, true);
111       return llvm::ConstantStruct::get(SType, Elts);
112     }
113 
114     return llvm::ConstantArray::get(AType, Elts);
115   }
116 
117   void InsertBitfieldIntoStruct(std::vector<llvm::Constant*>& Elts,
118                                 FieldDecl* Field, Expr* E) {
119     // Calculate the value to insert
120     llvm::Constant *C = CGM.EmitConstantExpr(E, CGF);
121     if (!C)
122       return;
123 
124     llvm::ConstantInt *CI = dyn_cast<llvm::ConstantInt>(C);
125     if (!CI) {
126       CGM.ErrorUnsupported(E, "bitfield initialization");
127       return;
128     }
129     llvm::APInt V = CI->getValue();
130 
131     // Calculate information about the relevant field
132     const llvm::Type* Ty = CI->getType();
133     const llvm::TargetData &TD = CGM.getTypes().getTargetData();
134     unsigned size = TD.getTypePaddedSizeInBits(Ty);
135     unsigned fieldOffset = CGM.getTypes().getLLVMFieldNo(Field) * size;
136     CodeGenTypes::BitFieldInfo bitFieldInfo =
137         CGM.getTypes().getBitFieldInfo(Field);
138     fieldOffset += bitFieldInfo.Begin;
139 
140     // Find where to start the insertion
141     // FIXME: This is O(n^2) in the number of bit-fields!
142     // FIXME: This won't work if the struct isn't completely packed!
143     unsigned offset = 0, i = 0;
144     while (offset < (fieldOffset & -8))
145       offset += TD.getTypePaddedSizeInBits(Elts[i++]->getType());
146 
147     // Advance over 0 sized elements (must terminate in bounds since
148     // the bitfield must have a size).
149     while (TD.getTypePaddedSizeInBits(Elts[i]->getType()) == 0)
150       ++i;
151 
152     // Promote the size of V if necessary
153     // FIXME: This should never occur, but currently it can because
154     // initializer constants are cast to bool, and because clang is
155     // not enforcing bitfield width limits.
156     if (bitFieldInfo.Size > V.getBitWidth())
157       V.zext(bitFieldInfo.Size);
158 
159     // Insert the bits into the struct
160     // FIXME: This algorthm is only correct on X86!
161     // FIXME: THis algorthm assumes bit-fields only have byte-size elements!
162     unsigned bitsToInsert = bitFieldInfo.Size;
163     unsigned curBits = std::min(8 - (fieldOffset & 7), bitsToInsert);
164     unsigned byte = V.getLoBits(curBits).getZExtValue() << (fieldOffset & 7);
165     do {
166       llvm::Constant* byteC = llvm::ConstantInt::get(llvm::Type::Int8Ty, byte);
167       Elts[i] = llvm::ConstantExpr::getOr(Elts[i], byteC);
168       ++i;
169       V = V.lshr(curBits);
170       bitsToInsert -= curBits;
171 
172       if (!bitsToInsert)
173         break;
174 
175       curBits = bitsToInsert > 8 ? 8 : bitsToInsert;
176       byte = V.getLoBits(curBits).getZExtValue();
177     } while (true);
178   }
179 
180   llvm::Constant *EmitStructInitialization(InitListExpr *ILE) {
181     const llvm::StructType *SType =
182         cast<llvm::StructType>(ConvertType(ILE->getType()));
183     RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl();
184     std::vector<llvm::Constant*> Elts;
185 
186     // Initialize the whole structure to zero.
187     for (unsigned i = 0; i < SType->getNumElements(); ++i) {
188       const llvm::Type *FieldTy = SType->getElementType(i);
189       Elts.push_back(llvm::Constant::getNullValue(FieldTy));
190     }
191 
192     // Copy initializer elements. Skip padding fields.
193     unsigned EltNo = 0;  // Element no in ILE
194     int FieldNo = 0; // Field no in RecordDecl
195     bool RewriteType = false;
196     for (RecordDecl::field_iterator Field = RD->field_begin(),
197                                  FieldEnd = RD->field_end();
198          EltNo < ILE->getNumInits() && Field != FieldEnd; ++Field) {
199       FieldNo++;
200       if (!Field->getIdentifier())
201         continue;
202 
203       if (Field->isBitField()) {
204         InsertBitfieldIntoStruct(Elts, *Field, ILE->getInit(EltNo));
205       } else {
206         unsigned FieldNo = CGM.getTypes().getLLVMFieldNo(*Field);
207         llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(EltNo), CGF);
208         if (!C) return 0;
209         RewriteType |= (C->getType() != Elts[FieldNo]->getType());
210         Elts[FieldNo] = C;
211       }
212       EltNo++;
213     }
214 
215     if (RewriteType) {
216       // FIXME: Make this work for non-packed structs
217       assert(SType->isPacked() && "Cannot recreate unpacked structs");
218       std::vector<const llvm::Type*> Types;
219       for (unsigned i = 0; i < Elts.size(); ++i)
220         Types.push_back(Elts[i]->getType());
221       SType = llvm::StructType::get(Types, true);
222     }
223 
224     return llvm::ConstantStruct::get(SType, Elts);
225   }
226 
227   llvm::Constant *EmitUnion(llvm::Constant *C, const llvm::Type *Ty) {
228     if (!C)
229       return 0;
230 
231     // Build a struct with the union sub-element as the first member,
232     // and padded to the appropriate size
233     std::vector<llvm::Constant*> Elts;
234     std::vector<const llvm::Type*> Types;
235     Elts.push_back(C);
236     Types.push_back(C->getType());
237     unsigned CurSize = CGM.getTargetData().getTypePaddedSize(C->getType());
238     unsigned TotalSize = CGM.getTargetData().getTypePaddedSize(Ty);
239     while (CurSize < TotalSize) {
240       Elts.push_back(llvm::Constant::getNullValue(llvm::Type::Int8Ty));
241       Types.push_back(llvm::Type::Int8Ty);
242       CurSize++;
243     }
244 
245     // This always generates a packed struct
246     // FIXME: Try to generate an unpacked struct when we can
247     llvm::StructType* STy = llvm::StructType::get(Types, true);
248     return llvm::ConstantStruct::get(STy, Elts);
249   }
250 
251   llvm::Constant *EmitUnionInitialization(InitListExpr *ILE) {
252     const llvm::Type *Ty = ConvertType(ILE->getType());
253 
254     // If this is an empty initializer list, we value-initialize the
255     // union.
256     if (ILE->getNumInits() == 0)
257       return llvm::Constant::getNullValue(Ty);
258 
259     FieldDecl* curField = ILE->getInitializedFieldInUnion();
260     if (!curField) {
261       // There's no field to initialize, so value-initialize the union.
262 #ifndef NDEBUG
263       // Make sure that it's really an empty and not a failure of
264       // semantic analysis.
265       RecordDecl *RD = ILE->getType()->getAsRecordType()->getDecl();
266       for (RecordDecl::field_iterator Field = RD->field_begin(),
267                                    FieldEnd = RD->field_end();
268            Field != FieldEnd; ++Field)
269         assert(Field->isUnnamedBitfield() && "Only unnamed bitfields allowed");
270 #endif
271       return llvm::Constant::getNullValue(Ty);
272     }
273 
274     if (curField->isBitField()) {
275       // Create a dummy struct for bit-field insertion
276       unsigned NumElts = CGM.getTargetData().getTypePaddedSize(Ty) / 8;
277       llvm::Constant* NV = llvm::Constant::getNullValue(llvm::Type::Int8Ty);
278       std::vector<llvm::Constant*> Elts(NumElts, NV);
279 
280       InsertBitfieldIntoStruct(Elts, curField, ILE->getInit(0));
281       const llvm::ArrayType *RetTy =
282           llvm::ArrayType::get(NV->getType(), NumElts);
283       return llvm::ConstantArray::get(RetTy, Elts);
284     }
285 
286     return EmitUnion(CGM.EmitConstantExpr(ILE->getInit(0), CGF), Ty);
287   }
288 
289   llvm::Constant *EmitVectorInitialization(InitListExpr *ILE) {
290     const llvm::VectorType *VType =
291         cast<llvm::VectorType>(ConvertType(ILE->getType()));
292     const llvm::Type *ElemTy = VType->getElementType();
293     std::vector<llvm::Constant*> Elts;
294     unsigned NumElements = VType->getNumElements();
295     unsigned NumInitElements = ILE->getNumInits();
296 
297     unsigned NumInitableElts = std::min(NumInitElements, NumElements);
298 
299     // Copy initializer elements.
300     unsigned i = 0;
301     for (; i < NumInitableElts; ++i) {
302       llvm::Constant *C = CGM.EmitConstantExpr(ILE->getInit(i), CGF);
303       if (!C)
304         return 0;
305       Elts.push_back(C);
306     }
307 
308     for (; i < NumElements; ++i)
309       Elts.push_back(llvm::Constant::getNullValue(ElemTy));
310 
311     return llvm::ConstantVector::get(VType, Elts);
312   }
313 
314   llvm::Constant *VisitImplicitValueInitExpr(ImplicitValueInitExpr* E) {
315     const llvm::Type* RetTy = CGM.getTypes().ConvertType(E->getType());
316     return llvm::Constant::getNullValue(RetTy);
317   }
318 
319   llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
320     if (ILE->getType()->isScalarType()) {
321       // We have a scalar in braces. Just use the first element.
322       if (ILE->getNumInits() > 0)
323         return CGM.EmitConstantExpr(ILE->getInit(0), CGF);
324 
325       const llvm::Type* RetTy = CGM.getTypes().ConvertType(ILE->getType());
326       return llvm::Constant::getNullValue(RetTy);
327     }
328 
329     if (ILE->getType()->isArrayType())
330       return EmitArrayInitialization(ILE);
331 
332     if (ILE->getType()->isStructureType())
333       return EmitStructInitialization(ILE);
334 
335     if (ILE->getType()->isUnionType())
336       return EmitUnionInitialization(ILE);
337 
338     if (ILE->getType()->isVectorType())
339       return EmitVectorInitialization(ILE);
340 
341     assert(0 && "Unable to handle InitListExpr");
342     // Get rid of control reaches end of void function warning.
343     // Not reached.
344     return 0;
345   }
346 
347   llvm::Constant *VisitStringLiteral(StringLiteral *E) {
348     assert(!E->getType()->isPointerType() && "Strings are always arrays");
349 
350     // This must be a string initializing an array in a static initializer.
351     // Don't emit it as the address of the string, emit the string data itself
352     // as an inline array.
353     return llvm::ConstantArray::get(CGM.GetStringForStringLiteral(E), false);
354   }
355 
356   llvm::Constant *VisitObjCEncodeExpr(ObjCEncodeExpr *E) {
357     // This must be an @encode initializing an array in a static initializer.
358     // Don't emit it as the address of the string, emit the string data itself
359     // as an inline array.
360     std::string Str;
361     CGM.getContext().getObjCEncodingForType(E->getEncodedType(), Str);
362     const ConstantArrayType *CAT = cast<ConstantArrayType>(E->getType());
363 
364     // Resize the string to the right size, adding zeros at the end, or
365     // truncating as needed.
366     Str.resize(CAT->getSize().getZExtValue(), '\0');
367     return llvm::ConstantArray::get(Str, false);
368   }
369 
370   llvm::Constant *VisitUnaryExtension(const UnaryOperator *E) {
371     return Visit(E->getSubExpr());
372   }
373 
374   // Utility methods
375   const llvm::Type *ConvertType(QualType T) {
376     return CGM.getTypes().ConvertType(T);
377   }
378 
379 public:
380   llvm::Constant *EmitLValue(Expr *E) {
381     switch (E->getStmtClass()) {
382     default: break;
383     case Expr::CompoundLiteralExprClass: {
384       // Note that due to the nature of compound literals, this is guaranteed
385       // to be the only use of the variable, so we just generate it here.
386       CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
387       llvm::Constant* C = Visit(CLE->getInitializer());
388       // FIXME: "Leaked" on failure.
389       if (C)
390         C = new llvm::GlobalVariable(C->getType(),
391                                      E->getType().isConstQualified(),
392                                      llvm::GlobalValue::InternalLinkage,
393                                      C, ".compoundliteral", &CGM.getModule());
394       return C;
395     }
396     case Expr::DeclRefExprClass:
397     case Expr::QualifiedDeclRefExprClass: {
398       NamedDecl *Decl = cast<DeclRefExpr>(E)->getDecl();
399       if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
400         return CGM.GetAddrOfFunction(FD);
401       if (const VarDecl* VD = dyn_cast<VarDecl>(Decl)) {
402         // We can never refer to a variable with local storage.
403         if (!VD->hasLocalStorage()) {
404           if (VD->isFileVarDecl() || VD->hasExternalStorage())
405             return CGM.GetAddrOfGlobalVar(VD);
406           else if (VD->isBlockVarDecl()) {
407             assert(CGF && "Can't access static local vars without CGF");
408             return CGF->GetAddrOfStaticLocalVar(VD);
409           }
410         }
411       }
412       break;
413     }
414     case Expr::StringLiteralClass:
415       return CGM.GetAddrOfConstantStringFromLiteral(cast<StringLiteral>(E));
416     case Expr::ObjCEncodeExprClass:
417       return CGM.GetAddrOfConstantStringFromObjCEncode(cast<ObjCEncodeExpr>(E));
418     case Expr::ObjCStringLiteralClass: {
419       ObjCStringLiteral* SL = cast<ObjCStringLiteral>(E);
420       llvm::Constant *C = CGM.getObjCRuntime().GenerateConstantString(SL);
421       return llvm::ConstantExpr::getBitCast(C, ConvertType(E->getType()));
422     }
423     case Expr::PredefinedExprClass: {
424       // __func__/__FUNCTION__ -> "".  __PRETTY_FUNCTION__ -> "top level".
425       std::string Str;
426       if (cast<PredefinedExpr>(E)->getIdentType() ==
427           PredefinedExpr::PrettyFunction)
428         Str = "top level";
429 
430       return CGM.GetAddrOfConstantCString(Str, ".tmp");
431     }
432     case Expr::AddrLabelExprClass: {
433       assert(CGF && "Invalid address of label expression outside function.");
434       unsigned id = CGF->GetIDForAddrOfLabel(cast<AddrLabelExpr>(E)->getLabel());
435       llvm::Constant *C = llvm::ConstantInt::get(llvm::Type::Int32Ty, id);
436       return llvm::ConstantExpr::getIntToPtr(C, ConvertType(E->getType()));
437     }
438     case Expr::CallExprClass: {
439       CallExpr* CE = cast<CallExpr>(E);
440       if (CE->isBuiltinCall(CGM.getContext()) !=
441             Builtin::BI__builtin___CFStringMakeConstantString)
442         break;
443       const Expr *Arg = CE->getArg(0)->IgnoreParenCasts();
444       const StringLiteral *Literal = cast<StringLiteral>(Arg);
445       std::string S(Literal->getStrData(), Literal->getByteLength());
446       // FIXME: need to deal with UCN conversion issues.
447       return CGM.GetAddrOfConstantCFString(S);
448     }
449     case Expr::BlockExprClass: {
450       std::string FunctionName;
451       if (CGF)
452         FunctionName = CGF->CurFn->getName();
453       else
454         FunctionName = "global";
455 
456       return CGM.GetAddrOfGlobalBlock(cast<BlockExpr>(E), FunctionName.c_str());
457     }
458     }
459 
460     return 0;
461   }
462 };
463 
464 }  // end anonymous namespace.
465 
466 llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
467                                                 CodeGenFunction *CGF) {
468   Expr::EvalResult Result;
469 
470   if (E->Evaluate(Result, Context)) {
471     assert(!Result.HasSideEffects &&
472            "Constant expr should not have any side effects!");
473     switch (Result.Val.getKind()) {
474     case APValue::Uninitialized:
475       assert(0 && "Constant expressions should be initialized.");
476       return 0;
477     case APValue::LValue: {
478       const llvm::Type *DestType = getTypes().ConvertTypeForMem(E->getType());
479       llvm::Constant *Offset =
480         llvm::ConstantInt::get(llvm::Type::Int64Ty,
481                                Result.Val.getLValueOffset());
482 
483       llvm::Constant *C;
484       if (const Expr *LVBase = Result.Val.getLValueBase()) {
485         C = ConstExprEmitter(*this, CGF).EmitLValue(const_cast<Expr*>(LVBase));
486 
487         // Apply offset if necessary.
488         if (!Offset->isNullValue()) {
489           const llvm::Type *Type =
490             llvm::PointerType::getUnqual(llvm::Type::Int8Ty);
491           llvm::Constant *Casted = llvm::ConstantExpr::getBitCast(C, Type);
492           Casted = llvm::ConstantExpr::getGetElementPtr(Casted, &Offset, 1);
493           C = llvm::ConstantExpr::getBitCast(Casted, C->getType());
494         }
495 
496         // Convert to the appropriate type; this could be an lvalue for
497         // an integer.
498         if (isa<llvm::PointerType>(DestType))
499           return llvm::ConstantExpr::getBitCast(C, DestType);
500 
501         return llvm::ConstantExpr::getPtrToInt(C, DestType);
502       } else {
503         C = Offset;
504 
505         // Convert to the appropriate type; this could be an lvalue for
506         // an integer.
507         if (isa<llvm::PointerType>(DestType))
508           return llvm::ConstantExpr::getIntToPtr(C, DestType);
509 
510         // If the types don't match this should only be a truncate.
511         if (C->getType() != DestType)
512           return llvm::ConstantExpr::getTrunc(C, DestType);
513 
514         return C;
515       }
516     }
517     case APValue::Int: {
518       llvm::Constant *C = llvm::ConstantInt::get(Result.Val.getInt());
519 
520       if (C->getType() == llvm::Type::Int1Ty) {
521         const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
522         C = llvm::ConstantExpr::getZExt(C, BoolTy);
523       }
524       return C;
525     }
526     case APValue::ComplexInt: {
527       llvm::Constant *Complex[2];
528 
529       Complex[0] = llvm::ConstantInt::get(Result.Val.getComplexIntReal());
530       Complex[1] = llvm::ConstantInt::get(Result.Val.getComplexIntImag());
531 
532       return llvm::ConstantStruct::get(Complex, 2);
533     }
534     case APValue::Float:
535       return llvm::ConstantFP::get(Result.Val.getFloat());
536     case APValue::ComplexFloat: {
537       llvm::Constant *Complex[2];
538 
539       Complex[0] = llvm::ConstantFP::get(Result.Val.getComplexFloatReal());
540       Complex[1] = llvm::ConstantFP::get(Result.Val.getComplexFloatImag());
541 
542       return llvm::ConstantStruct::get(Complex, 2);
543     }
544     case APValue::Vector: {
545       llvm::SmallVector<llvm::Constant *, 4> Inits;
546       unsigned NumElts = Result.Val.getVectorLength();
547 
548       for (unsigned i = 0; i != NumElts; ++i) {
549         APValue &Elt = Result.Val.getVectorElt(i);
550         if (Elt.isInt())
551           Inits.push_back(llvm::ConstantInt::get(Elt.getInt()));
552         else
553           Inits.push_back(llvm::ConstantFP::get(Elt.getFloat()));
554       }
555       return llvm::ConstantVector::get(&Inits[0], Inits.size());
556     }
557     }
558   }
559 
560   llvm::Constant* C = ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));
561   if (C && C->getType() == llvm::Type::Int1Ty) {
562     const llvm::Type *BoolTy = getTypes().ConvertTypeForMem(E->getType());
563     C = llvm::ConstantExpr::getZExt(C, BoolTy);
564   }
565   return C;
566 }
567