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