1 //===--- CGExprConstant.cpp - Emit LLVM Code from Constant Expressions ----===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This contains code to emit Constant Expr nodes as LLVM code.
12 //===----------------------------------------------------------------------===//
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 using namespace clang;
22 using namespace CodeGen;
25 class VISIBILITY_HIDDEN ConstExprEmitter :
26 public StmtVisitor<ConstExprEmitter, llvm::Constant*> {
30 ConstExprEmitter(CodeGenModule &cgm, CodeGenFunction *cgf)
31 : CGM(cgm), CGF(cgf) {
34 //===--------------------------------------------------------------------===//
36 //===--------------------------------------------------------------------===//
38 llvm::Constant *VisitStmt(Stmt *S) {
39 CGM.WarnUnsupported(S, "constant expression");
40 return llvm::UndefValue::get(CGM.getTypes().ConvertType(cast<Expr>(S)->getType()));
43 llvm::Constant *VisitParenExpr(ParenExpr *PE) {
44 return Visit(PE->getSubExpr());
48 llvm::Constant *VisitIntegerLiteral(const IntegerLiteral *E) {
49 return llvm::ConstantInt::get(E->getValue());
51 llvm::Constant *VisitFloatingLiteral(const FloatingLiteral *E) {
52 return llvm::ConstantFP::get(ConvertType(E->getType()), E->getValue());
54 llvm::Constant *VisitCharacterLiteral(const CharacterLiteral *E) {
55 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
57 llvm::Constant *VisitCXXBoolLiteralExpr(const CXXBoolLiteralExpr *E) {
58 return llvm::ConstantInt::get(ConvertType(E->getType()), E->getValue());
61 llvm::Constant *VisitCompoundLiteralExpr(CompoundLiteralExpr *E) {
62 return Visit(E->getInitializer());
65 llvm::Constant *VisitCastExpr(const CastExpr* E) {
66 llvm::Constant *C = Visit(E->getSubExpr());
68 return EmitConversion(C, E->getSubExpr()->getType(), E->getType());
71 llvm::Constant *EmitArrayInitialization(InitListExpr *ILE,
72 const llvm::ArrayType *AType) {
73 std::vector<llvm::Constant*> Elts;
74 unsigned NumInitElements = ILE->getNumInits();
75 // FIXME: Check for wide strings
76 if (NumInitElements > 0 && isa<StringLiteral>(ILE->getInit(0)) &&
77 ILE->getType()->getAsArrayType()->getElementType()->isCharType())
78 return Visit(ILE->getInit(0));
79 const llvm::Type *ElemTy = AType->getElementType();
80 unsigned NumElements = AType->getNumElements();
82 // Initialising an array requires us to automatically
83 // initialise any elements that have not been initialised explicitly
84 unsigned NumInitableElts = std::min(NumInitElements, NumElements);
86 // Copy initializer elements.
88 for (; i < NumInitableElts; ++i) {
90 llvm::Constant *C = Visit(ILE->getInit(i));
91 // FIXME: Remove this when sema of initializers is finished (and the code
93 if (C == 0 && ILE->getInit(i)->getType()->isVoidType()) {
94 if (ILE->getType()->isVoidType()) return 0;
95 return llvm::UndefValue::get(AType);
97 assert (C && "Failed to create initializer expression");
101 // Initialize remaining array elements.
102 for (; i < NumElements; ++i)
103 Elts.push_back(llvm::Constant::getNullValue(ElemTy));
105 return llvm::ConstantArray::get(AType, Elts);
108 llvm::Constant *EmitStructInitialization(InitListExpr *ILE,
109 const llvm::StructType *SType) {
111 TagDecl *TD = ILE->getType()->getAsRecordType()->getDecl();
112 std::vector<llvm::Constant*> Elts;
113 const CGRecordLayout *CGR = CGM.getTypes().getCGRecordLayout(TD);
114 unsigned NumInitElements = ILE->getNumInits();
115 unsigned NumElements = SType->getNumElements();
117 // Initialising an structure requires us to automatically
118 // initialise any elements that have not been initialised explicitly
119 unsigned NumInitableElts = std::min(NumInitElements, NumElements);
121 // Copy initializer elements. Skip padding fields.
122 unsigned EltNo = 0; // Element no in ILE
123 unsigned FieldNo = 0; // Field no in SType
124 while (EltNo < NumInitableElts) {
126 // Zero initialize padding field.
127 if (CGR->isPaddingField(FieldNo)) {
128 const llvm::Type *FieldTy = SType->getElementType(FieldNo);
129 Elts.push_back(llvm::Constant::getNullValue(FieldTy));
134 llvm::Constant *C = Visit(ILE->getInit(EltNo));
135 // FIXME: Remove this when sema of initializers is finished (and the code
137 if (C == 0 && ILE->getInit(EltNo)->getType()->isVoidType()) {
138 if (ILE->getType()->isVoidType()) return 0;
139 return llvm::UndefValue::get(SType);
141 assert (C && "Failed to create initializer expression");
147 // Initialize remaining structure elements.
148 for (unsigned i = Elts.size(); i < NumElements; ++i) {
149 const llvm::Type *FieldTy = SType->getElementType(i);
150 Elts.push_back(llvm::Constant::getNullValue(FieldTy));
153 return llvm::ConstantStruct::get(SType, Elts);
156 llvm::Constant *EmitVectorInitialization(InitListExpr *ILE,
157 const llvm::VectorType *VType) {
159 std::vector<llvm::Constant*> Elts;
160 unsigned NumInitElements = ILE->getNumInits();
161 unsigned NumElements = VType->getNumElements();
163 assert (NumInitElements == NumElements
164 && "Unsufficient vector init elelments");
165 // Copy initializer elements.
167 for (; i < NumElements; ++i) {
169 llvm::Constant *C = Visit(ILE->getInit(i));
170 // FIXME: Remove this when sema of initializers is finished (and the code
172 if (C == 0 && ILE->getInit(i)->getType()->isVoidType()) {
173 if (ILE->getType()->isVoidType()) return 0;
174 return llvm::UndefValue::get(VType);
176 assert (C && "Failed to create initializer expression");
180 return llvm::ConstantVector::get(VType, Elts);
183 llvm::Constant *VisitInitListExpr(InitListExpr *ILE) {
184 const llvm::CompositeType *CType =
185 dyn_cast<llvm::CompositeType>(ConvertType(ILE->getType()));
188 // We have a scalar in braces. Just use the first element.
189 return Visit(ILE->getInit(0));
192 if (const llvm::ArrayType *AType = dyn_cast<llvm::ArrayType>(CType))
193 return EmitArrayInitialization(ILE, AType);
195 if (const llvm::StructType *SType = dyn_cast<llvm::StructType>(CType))
196 return EmitStructInitialization(ILE, SType);
198 if (const llvm::VectorType *VType = dyn_cast<llvm::VectorType>(CType))
199 return EmitVectorInitialization(ILE, VType);
201 // Make sure we have an array at this point
202 assert(0 && "Unable to handle InitListExpr");
205 llvm::Constant *VisitImplicitCastExpr(ImplicitCastExpr *ICExpr) {
206 Expr* SExpr = ICExpr->getSubExpr();
207 QualType SType = SExpr->getType();
208 llvm::Constant *C; // the intermediate expression
209 QualType T; // the type of the intermediate expression
210 if (SType->isArrayType()) {
211 // Arrays decay to a pointer to the first element
212 // VLAs would require special handling, but they can't occur here
213 C = EmitLValue(SExpr);
214 llvm::Constant *Idx0 = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
215 llvm::Constant *Ops[] = {Idx0, Idx0};
216 C = llvm::ConstantExpr::getGetElementPtr(C, Ops, 2);
218 QualType ElemType = SType->getAsArrayType()->getElementType();
219 T = CGM.getContext().getPointerType(ElemType);
220 } else if (SType->isFunctionType()) {
221 // Function types decay to a pointer to the function
222 C = EmitLValue(SExpr);
223 T = CGM.getContext().getPointerType(SType);
229 // Perform the conversion; note that an implicit cast can both promote
230 // and convert an array/function
231 return EmitConversion(C, T, ICExpr->getType());
234 llvm::Constant *VisitStringLiteral(StringLiteral *E) {
235 const char *StrData = E->getStrData();
236 unsigned Len = E->getByteLength();
237 assert(!E->getType()->isPointerType() && "Strings are always arrays");
239 // Otherwise this must be a string initializing an array in a static
240 // initializer. Don't emit it as the address of the string, emit the string
241 // data itself as an inline array.
242 const ConstantArrayType *CAT = E->getType()->getAsConstantArrayType();
243 assert(CAT && "String isn't pointer or array!");
245 std::string Str(StrData, StrData + Len);
246 // Null terminate the string before potentially truncating it.
247 // FIXME: What about wchar_t strings?
250 uint64_t RealLen = CAT->getSize().getZExtValue();
251 // String or grow the initializer to the required size.
252 if (RealLen != Str.size())
255 return llvm::ConstantArray::get(Str, false);
258 llvm::Constant *VisitDeclRefExpr(DeclRefExpr *E) {
259 const ValueDecl *Decl = E->getDecl();
260 if (const EnumConstantDecl *EC = dyn_cast<EnumConstantDecl>(Decl))
261 return llvm::ConstantInt::get(EC->getInitVal());
262 assert(0 && "Unsupported decl ref type!");
266 llvm::Constant *VisitSizeOfAlignOfTypeExpr(const SizeOfAlignOfTypeExpr *E) {
267 return EmitSizeAlignOf(E->getArgumentType(), E->getType(), E->isSizeOf());
271 llvm::Constant *VisitUnaryPlus(const UnaryOperator *E) {
272 return Visit(E->getSubExpr());
274 llvm::Constant *VisitUnaryMinus(const UnaryOperator *E) {
275 return llvm::ConstantExpr::getNeg(Visit(E->getSubExpr()));
277 llvm::Constant *VisitUnaryNot(const UnaryOperator *E) {
278 return llvm::ConstantExpr::getNot(Visit(E->getSubExpr()));
280 llvm::Constant *VisitUnaryLNot(const UnaryOperator *E) {
281 llvm::Constant *SubExpr = Visit(E->getSubExpr());
283 if (E->getSubExpr()->getType()->isRealFloatingType()) {
284 // Compare against 0.0 for fp scalars.
285 llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType());
286 SubExpr = llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UEQ, SubExpr,
289 assert((E->getSubExpr()->getType()->isIntegerType() ||
290 E->getSubExpr()->getType()->isPointerType()) &&
291 "Unknown scalar type to convert");
292 // Compare against an integer or pointer null.
293 llvm::Constant *Zero = llvm::Constant::getNullValue(SubExpr->getType());
294 SubExpr = llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_EQ, SubExpr,
298 return llvm::ConstantExpr::getZExt(SubExpr, ConvertType(E->getType()));
300 llvm::Constant *VisitUnarySizeOf(const UnaryOperator *E) {
301 return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), true);
303 llvm::Constant *VisitUnaryAlignOf(const UnaryOperator *E) {
304 return EmitSizeAlignOf(E->getSubExpr()->getType(), E->getType(), false);
306 llvm::Constant *VisitUnaryAddrOf(const UnaryOperator *E) {
307 return EmitLValue(E->getSubExpr());
309 llvm::Constant *VisitUnaryOffsetOf(const UnaryOperator *E) {
310 int64_t Val = E->evaluateOffsetOf(CGM.getContext());
312 assert(E->getType()->isIntegerType() && "Result type must be an integer!");
314 uint32_t ResultWidth = static_cast<uint32_t>(
315 CGM.getContext().getTypeSize(E->getType(), SourceLocation()));
316 return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
320 llvm::Constant *VisitBinOr(const BinaryOperator *E) {
321 llvm::Constant *LHS = Visit(E->getLHS());
322 llvm::Constant *RHS = Visit(E->getRHS());
324 return llvm::ConstantExpr::getOr(LHS, RHS);
326 llvm::Constant *VisitBinSub(const BinaryOperator *E) {
327 llvm::Constant *LHS = Visit(E->getLHS());
328 llvm::Constant *RHS = Visit(E->getRHS());
330 if (!isa<llvm::PointerType>(RHS->getType())) {
332 if (isa<llvm::PointerType>(LHS->getType())) {
333 llvm::Constant *Idx = llvm::ConstantExpr::getNeg(RHS);
335 return llvm::ConstantExpr::getGetElementPtr(LHS, &Idx, 1);
339 return llvm::ConstantExpr::getSub(LHS, RHS);
342 assert(0 && "Unhandled bin sub case!");
346 llvm::Constant *VisitBinShl(const BinaryOperator *E) {
347 llvm::Constant *LHS = Visit(E->getLHS());
348 llvm::Constant *RHS = Visit(E->getRHS());
350 // LLVM requires the LHS and RHS to be the same type: promote or truncate the
351 // RHS to the same size as the LHS.
352 if (LHS->getType() != RHS->getType())
353 RHS = llvm::ConstantExpr::getIntegerCast(RHS, LHS->getType(), false);
355 return llvm::ConstantExpr::getShl(LHS, RHS);
358 llvm::Constant *VisitBinMul(const BinaryOperator *E) {
359 llvm::Constant *LHS = Visit(E->getLHS());
360 llvm::Constant *RHS = Visit(E->getRHS());
362 return llvm::ConstantExpr::getMul(LHS, RHS);
365 llvm::Constant *VisitBinDiv(const BinaryOperator *E) {
366 llvm::Constant *LHS = Visit(E->getLHS());
367 llvm::Constant *RHS = Visit(E->getRHS());
369 if (LHS->getType()->isFPOrFPVector())
370 return llvm::ConstantExpr::getFDiv(LHS, RHS);
371 else if (E->getType()->isUnsignedIntegerType())
372 return llvm::ConstantExpr::getUDiv(LHS, RHS);
374 return llvm::ConstantExpr::getSDiv(LHS, RHS);
377 llvm::Constant *VisitBinAdd(const BinaryOperator *E) {
378 llvm::Constant *LHS = Visit(E->getLHS());
379 llvm::Constant *RHS = Visit(E->getRHS());
381 if (!E->getType()->isPointerType())
382 return llvm::ConstantExpr::getAdd(LHS, RHS);
384 llvm::Constant *Ptr, *Idx;
385 if (isa<llvm::PointerType>(LHS->getType())) { // pointer + int
388 } else { // int + pointer
393 return llvm::ConstantExpr::getGetElementPtr(Ptr, &Idx, 1);
396 llvm::Constant *VisitBinAnd(const BinaryOperator *E) {
397 llvm::Constant *LHS = Visit(E->getLHS());
398 llvm::Constant *RHS = Visit(E->getRHS());
400 return llvm::ConstantExpr::getAnd(LHS, RHS);
404 const llvm::Type *ConvertType(QualType T) {
405 return CGM.getTypes().ConvertType(T);
408 llvm::Constant *EmitConversionToBool(llvm::Constant *Src, QualType SrcType) {
409 assert(SrcType->isCanonical() && "EmitConversion strips typedefs");
411 if (SrcType->isRealFloatingType()) {
412 // Compare against 0.0 for fp scalars.
413 llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType());
414 return llvm::ConstantExpr::getFCmp(llvm::FCmpInst::FCMP_UNE, Src, Zero);
417 assert((SrcType->isIntegerType() || SrcType->isPointerType()) &&
418 "Unknown scalar type to convert");
420 // Compare against an integer or pointer null.
421 llvm::Constant *Zero = llvm::Constant::getNullValue(Src->getType());
422 return llvm::ConstantExpr::getICmp(llvm::ICmpInst::ICMP_NE, Src, Zero);
425 llvm::Constant *EmitConversion(llvm::Constant *Src, QualType SrcType,
427 SrcType = SrcType.getCanonicalType();
428 DstType = DstType.getCanonicalType();
429 if (SrcType == DstType) return Src;
431 // Handle conversions to bool first, they are special: comparisons against 0.
432 if (DstType->isBooleanType())
433 return EmitConversionToBool(Src, SrcType);
435 const llvm::Type *DstTy = ConvertType(DstType);
437 // Ignore conversions like int -> uint.
438 if (Src->getType() == DstTy)
441 // Handle pointer conversions next: pointers can only be converted to/from
442 // other pointers and integers.
443 if (isa<PointerType>(DstType)) {
444 // The source value may be an integer, or a pointer.
445 if (isa<llvm::PointerType>(Src->getType()))
446 return llvm::ConstantExpr::getBitCast(Src, DstTy);
447 assert(SrcType->isIntegerType() &&"Not ptr->ptr or int->ptr conversion?");
448 return llvm::ConstantExpr::getIntToPtr(Src, DstTy);
451 if (isa<PointerType>(SrcType)) {
452 // Must be an ptr to int cast.
453 assert(isa<llvm::IntegerType>(DstTy) && "not ptr->int?");
454 return llvm::ConstantExpr::getPtrToInt(Src, DstTy);
457 // A scalar source can be splatted to a vector of the same element type
458 if (isa<llvm::VectorType>(DstTy) && !isa<VectorType>(SrcType)) {
459 const llvm::VectorType *VT = cast<llvm::VectorType>(DstTy);
460 assert((VT->getElementType() == Src->getType()) &&
461 "Vector element type must match scalar type to splat.");
462 unsigned NumElements = DstType->getAsVectorType()->getNumElements();
463 llvm::SmallVector<llvm::Constant*, 16> Elements;
464 for (unsigned i = 0; i < NumElements; i++)
465 Elements.push_back(Src);
467 return llvm::ConstantVector::get(&Elements[0], NumElements);
470 if (isa<llvm::VectorType>(Src->getType()) ||
471 isa<llvm::VectorType>(DstTy)) {
472 return llvm::ConstantExpr::getBitCast(Src, DstTy);
475 // Finally, we have the arithmetic types: real int/float.
476 if (isa<llvm::IntegerType>(Src->getType())) {
477 bool InputSigned = SrcType->isSignedIntegerType();
478 if (isa<llvm::IntegerType>(DstTy))
479 return llvm::ConstantExpr::getIntegerCast(Src, DstTy, InputSigned);
480 else if (InputSigned)
481 return llvm::ConstantExpr::getSIToFP(Src, DstTy);
483 return llvm::ConstantExpr::getUIToFP(Src, DstTy);
486 assert(Src->getType()->isFloatingPoint() && "Unknown real conversion");
487 if (isa<llvm::IntegerType>(DstTy)) {
488 if (DstType->isSignedIntegerType())
489 return llvm::ConstantExpr::getFPToSI(Src, DstTy);
491 return llvm::ConstantExpr::getFPToUI(Src, DstTy);
494 assert(DstTy->isFloatingPoint() && "Unknown real conversion");
495 if (DstTy->getTypeID() < Src->getType()->getTypeID())
496 return llvm::ConstantExpr::getFPTrunc(Src, DstTy);
498 return llvm::ConstantExpr::getFPExtend(Src, DstTy);
501 llvm::Constant *EmitSizeAlignOf(QualType TypeToSize,
502 QualType RetType, bool isSizeOf) {
503 std::pair<uint64_t, unsigned> Info =
504 CGM.getContext().getTypeInfo(TypeToSize, SourceLocation());
506 uint64_t Val = isSizeOf ? Info.first : Info.second;
507 Val /= 8; // Return size in bytes, not bits.
509 assert(RetType->isIntegerType() && "Result type must be an integer!");
511 uint32_t ResultWidth = static_cast<uint32_t>(
512 CGM.getContext().getTypeSize(RetType, SourceLocation()));
513 return llvm::ConstantInt::get(llvm::APInt(ResultWidth, Val));
516 llvm::Constant *EmitLValue(Expr *E) {
517 switch (E->getStmtClass()) {
519 case Expr::ParenExprClass:
521 return EmitLValue(cast<ParenExpr>(E)->getSubExpr());
522 case Expr::CompoundLiteralExprClass: {
523 // Note that due to the nature of compound literals, this is guaranteed
524 // to be the only use of the variable, so we just generate it here.
525 CompoundLiteralExpr *CLE = cast<CompoundLiteralExpr>(E);
526 llvm::Constant* C = Visit(CLE->getInitializer());
527 C = new llvm::GlobalVariable(C->getType(),E->getType().isConstQualified(),
528 llvm::GlobalValue::InternalLinkage,
529 C, ".compoundliteral", &CGM.getModule());
532 case Expr::DeclRefExprClass: {
533 ValueDecl *Decl = cast<DeclRefExpr>(E)->getDecl();
534 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Decl))
535 return CGM.GetAddrOfFunctionDecl(FD, false);
536 if (const FileVarDecl* VD = dyn_cast<FileVarDecl>(Decl))
537 return CGM.GetAddrOfGlobalVar(VD, false);
538 if (const BlockVarDecl* BVD = dyn_cast<BlockVarDecl>(Decl)) {
539 assert(CGF && "Can't access static local vars without CGF");
540 return CGF->GetAddrOfStaticLocalVar(BVD);
544 case Expr::MemberExprClass: {
545 MemberExpr* ME = cast<MemberExpr>(E);
546 llvm::Constant *Base;
548 Base = Visit(ME->getBase());
550 Base = EmitLValue(ME->getBase());
552 unsigned FieldNumber = CGM.getTypes().getLLVMFieldNo(ME->getMemberDecl());
553 llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
554 llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty,
556 llvm::Value *Ops[] = {Zero, Idx};
557 return llvm::ConstantExpr::getGetElementPtr(Base, Ops, 2);
559 case Expr::ArraySubscriptExprClass: {
560 ArraySubscriptExpr* ASExpr = cast<ArraySubscriptExpr>(E);
561 llvm::Constant *Base = Visit(ASExpr->getBase());
562 llvm::Constant *Index = Visit(ASExpr->getIdx());
563 assert(!ASExpr->getBase()->getType()->isVectorType() &&
564 "Taking the address of a vector component is illegal!");
565 return llvm::ConstantExpr::getGetElementPtr(Base, &Index, 1);
567 case Expr::StringLiteralClass: {
568 StringLiteral *String = cast<StringLiteral>(E);
569 assert(!String->isWide() && "Cannot codegen wide strings yet");
570 const char *StrData = String->getStrData();
571 unsigned Len = String->getByteLength();
573 return CGM.GetAddrOfConstantString(std::string(StrData, StrData + Len));
575 case Expr::UnaryOperatorClass: {
576 UnaryOperator *Exp = cast<UnaryOperator>(E);
577 switch (Exp->getOpcode()) {
579 case UnaryOperator::Extension:
580 // Extension is just a wrapper for expressions
581 return EmitLValue(Exp->getSubExpr());
582 case UnaryOperator::Real:
583 case UnaryOperator::Imag: {
584 // The address of __real or __imag is just a GEP off the address
585 // of the internal expression
586 llvm::Constant* C = EmitLValue(Exp->getSubExpr());
587 llvm::Constant *Zero = llvm::ConstantInt::get(llvm::Type::Int32Ty, 0);
588 llvm::Constant *Idx = llvm::ConstantInt::get(llvm::Type::Int32Ty,
589 Exp->getOpcode() == UnaryOperator::Imag);
590 llvm::Value *Ops[] = {Zero, Idx};
591 return llvm::ConstantExpr::getGetElementPtr(C, Ops, 2);
593 case UnaryOperator::Deref:
594 // The address of a deref is just the value of the expression
595 return Visit(Exp->getSubExpr());
600 CGM.WarnUnsupported(E, "constant l-value expression");
601 llvm::Type *Ty = llvm::PointerType::getUnqual(ConvertType(E->getType()));
602 return llvm::UndefValue::get(Ty);
607 } // end anonymous namespace.
610 llvm::Constant *CodeGenModule::EmitConstantExpr(const Expr *E,
611 CodeGenFunction *CGF)
613 QualType type = E->getType().getCanonicalType();
615 if (type->isIntegerType()) {
617 Value(static_cast<uint32_t>(Context.getTypeSize(type, SourceLocation())));
618 if (E->isIntegerConstantExpr(Value, Context)) {
619 return llvm::ConstantInt::get(Value);
623 return ConstExprEmitter(*this, CGF).Visit(const_cast<Expr*>(E));