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