CodeGenModule.cpp revision 293361afd4199c92aabff9267fddea890943c586
1//===--- CodeGenModule.cpp - Emit LLVM Code from ASTs for a Module --------===// 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 coordinates the per-module state used while generating code. 11// 12//===----------------------------------------------------------------------===// 13 14#include "CodeGenModule.h" 15#include "CGDebugInfo.h" 16#include "CodeGenFunction.h" 17#include "CGCall.h" 18#include "CGObjCRuntime.h" 19#include "Mangle.h" 20#include "clang/Frontend/CompileOptions.h" 21#include "clang/AST/ASTContext.h" 22#include "clang/AST/DeclObjC.h" 23#include "clang/AST/DeclCXX.h" 24#include "clang/Basic/Builtins.h" 25#include "clang/Basic/Diagnostic.h" 26#include "clang/Basic/SourceManager.h" 27#include "clang/Basic/TargetInfo.h" 28#include "clang/Basic/ConvertUTF.h" 29#include "llvm/CallingConv.h" 30#include "llvm/Module.h" 31#include "llvm/Intrinsics.h" 32#include "llvm/Target/TargetData.h" 33using namespace clang; 34using namespace CodeGen; 35 36 37CodeGenModule::CodeGenModule(ASTContext &C, const CompileOptions &compileOpts, 38 llvm::Module &M, const llvm::TargetData &TD, 39 Diagnostic &diags) 40 : BlockModule(C, M, TD, Types, *this), Context(C), 41 Features(C.getLangOptions()), CompileOpts(compileOpts), TheModule(M), 42 TheTargetData(TD), Diags(diags), Types(C, M, TD), Runtime(0), 43 MemCpyFn(0), MemMoveFn(0), MemSetFn(0), CFConstantStringClassRef(0), 44 VMContext(M.getContext()) { 45 46 if (!Features.ObjC1) 47 Runtime = 0; 48 else if (!Features.NeXTRuntime) 49 Runtime = CreateGNUObjCRuntime(*this); 50 else if (Features.ObjCNonFragileABI) 51 Runtime = CreateMacNonFragileABIObjCRuntime(*this); 52 else 53 Runtime = CreateMacObjCRuntime(*this); 54 55 // If debug info generation is enabled, create the CGDebugInfo object. 56 DebugInfo = CompileOpts.DebugInfo ? new CGDebugInfo(this) : 0; 57} 58 59CodeGenModule::~CodeGenModule() { 60 delete Runtime; 61 delete DebugInfo; 62} 63 64void CodeGenModule::Release() { 65 // We need to call this first because it can add deferred declarations. 66 EmitCXXGlobalInitFunc(); 67 68 EmitDeferred(); 69 if (Runtime) 70 if (llvm::Function *ObjCInitFunction = Runtime->ModuleInitFunction()) 71 AddGlobalCtor(ObjCInitFunction); 72 EmitCtorList(GlobalCtors, "llvm.global_ctors"); 73 EmitCtorList(GlobalDtors, "llvm.global_dtors"); 74 EmitAnnotations(); 75 EmitLLVMUsed(); 76} 77 78/// ErrorUnsupported - Print out an error that codegen doesn't support the 79/// specified stmt yet. 80void CodeGenModule::ErrorUnsupported(const Stmt *S, const char *Type, 81 bool OmitOnError) { 82 if (OmitOnError && getDiags().hasErrorOccurred()) 83 return; 84 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error, 85 "cannot compile this %0 yet"); 86 std::string Msg = Type; 87 getDiags().Report(Context.getFullLoc(S->getLocStart()), DiagID) 88 << Msg << S->getSourceRange(); 89} 90 91/// ErrorUnsupported - Print out an error that codegen doesn't support the 92/// specified decl yet. 93void CodeGenModule::ErrorUnsupported(const Decl *D, const char *Type, 94 bool OmitOnError) { 95 if (OmitOnError && getDiags().hasErrorOccurred()) 96 return; 97 unsigned DiagID = getDiags().getCustomDiagID(Diagnostic::Error, 98 "cannot compile this %0 yet"); 99 std::string Msg = Type; 100 getDiags().Report(Context.getFullLoc(D->getLocation()), DiagID) << Msg; 101} 102 103LangOptions::VisibilityMode 104CodeGenModule::getDeclVisibilityMode(const Decl *D) const { 105 if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 106 if (VD->getStorageClass() == VarDecl::PrivateExtern) 107 return LangOptions::Hidden; 108 109 if (const VisibilityAttr *attr = D->getAttr<VisibilityAttr>()) { 110 switch (attr->getVisibility()) { 111 default: assert(0 && "Unknown visibility!"); 112 case VisibilityAttr::DefaultVisibility: 113 return LangOptions::Default; 114 case VisibilityAttr::HiddenVisibility: 115 return LangOptions::Hidden; 116 case VisibilityAttr::ProtectedVisibility: 117 return LangOptions::Protected; 118 } 119 } 120 121 return getLangOptions().getVisibilityMode(); 122} 123 124void CodeGenModule::setGlobalVisibility(llvm::GlobalValue *GV, 125 const Decl *D) const { 126 // Internal definitions always have default visibility. 127 if (GV->hasLocalLinkage()) { 128 GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 129 return; 130 } 131 132 switch (getDeclVisibilityMode(D)) { 133 default: assert(0 && "Unknown visibility!"); 134 case LangOptions::Default: 135 return GV->setVisibility(llvm::GlobalValue::DefaultVisibility); 136 case LangOptions::Hidden: 137 return GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 138 case LangOptions::Protected: 139 return GV->setVisibility(llvm::GlobalValue::ProtectedVisibility); 140 } 141} 142 143const char *CodeGenModule::getMangledName(const GlobalDecl &GD) { 144 const NamedDecl *ND = GD.getDecl(); 145 146 if (const CXXConstructorDecl *D = dyn_cast<CXXConstructorDecl>(ND)) 147 return getMangledCXXCtorName(D, GD.getCtorType()); 148 if (const CXXDestructorDecl *D = dyn_cast<CXXDestructorDecl>(ND)) 149 return getMangledCXXDtorName(D, GD.getDtorType()); 150 151 return getMangledName(ND); 152} 153 154/// \brief Retrieves the mangled name for the given declaration. 155/// 156/// If the given declaration requires a mangled name, returns an 157/// const char* containing the mangled name. Otherwise, returns 158/// the unmangled name. 159/// 160const char *CodeGenModule::getMangledName(const NamedDecl *ND) { 161 // In C, functions with no attributes never need to be mangled. Fastpath them. 162 if (!getLangOptions().CPlusPlus && !ND->hasAttrs()) { 163 assert(ND->getIdentifier() && "Attempt to mangle unnamed decl."); 164 return ND->getNameAsCString(); 165 } 166 167 llvm::SmallString<256> Name; 168 llvm::raw_svector_ostream Out(Name); 169 if (!mangleName(ND, Context, Out)) { 170 assert(ND->getIdentifier() && "Attempt to mangle unnamed decl."); 171 return ND->getNameAsCString(); 172 } 173 174 Name += '\0'; 175 return UniqueMangledName(Name.begin(), Name.end()); 176} 177 178const char *CodeGenModule::UniqueMangledName(const char *NameStart, 179 const char *NameEnd) { 180 assert(*(NameEnd - 1) == '\0' && "Mangled name must be null terminated!"); 181 182 return MangledNames.GetOrCreateValue(NameStart, NameEnd).getKeyData(); 183} 184 185/// AddGlobalCtor - Add a function to the list that will be called before 186/// main() runs. 187void CodeGenModule::AddGlobalCtor(llvm::Function * Ctor, int Priority) { 188 // FIXME: Type coercion of void()* types. 189 GlobalCtors.push_back(std::make_pair(Ctor, Priority)); 190} 191 192/// AddGlobalDtor - Add a function to the list that will be called 193/// when the module is unloaded. 194void CodeGenModule::AddGlobalDtor(llvm::Function * Dtor, int Priority) { 195 // FIXME: Type coercion of void()* types. 196 GlobalDtors.push_back(std::make_pair(Dtor, Priority)); 197} 198 199void CodeGenModule::EmitCtorList(const CtorList &Fns, const char *GlobalName) { 200 // Ctor function type is void()*. 201 llvm::FunctionType* CtorFTy = 202 llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 203 std::vector<const llvm::Type*>(), 204 false); 205 llvm::Type *CtorPFTy = llvm::PointerType::getUnqual(CtorFTy); 206 207 // Get the type of a ctor entry, { i32, void ()* }. 208 llvm::StructType* CtorStructTy = 209 llvm::StructType::get(VMContext, llvm::Type::getInt32Ty(VMContext), 210 llvm::PointerType::getUnqual(CtorFTy), NULL); 211 212 // Construct the constructor and destructor arrays. 213 std::vector<llvm::Constant*> Ctors; 214 for (CtorList::const_iterator I = Fns.begin(), E = Fns.end(); I != E; ++I) { 215 std::vector<llvm::Constant*> S; 216 S.push_back(llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), 217 I->second, false)); 218 S.push_back(llvm::ConstantExpr::getBitCast(I->first, CtorPFTy)); 219 Ctors.push_back(llvm::ConstantStruct::get(CtorStructTy, S)); 220 } 221 222 if (!Ctors.empty()) { 223 llvm::ArrayType *AT = llvm::ArrayType::get(CtorStructTy, Ctors.size()); 224 new llvm::GlobalVariable(TheModule, AT, false, 225 llvm::GlobalValue::AppendingLinkage, 226 llvm::ConstantArray::get(AT, Ctors), 227 GlobalName); 228 } 229} 230 231void CodeGenModule::EmitAnnotations() { 232 if (Annotations.empty()) 233 return; 234 235 // Create a new global variable for the ConstantStruct in the Module. 236 llvm::Constant *Array = 237 llvm::ConstantArray::get(llvm::ArrayType::get(Annotations[0]->getType(), 238 Annotations.size()), 239 Annotations); 240 llvm::GlobalValue *gv = 241 new llvm::GlobalVariable(TheModule, Array->getType(), false, 242 llvm::GlobalValue::AppendingLinkage, Array, 243 "llvm.global.annotations"); 244 gv->setSection("llvm.metadata"); 245} 246 247static CodeGenModule::GVALinkage 248GetLinkageForFunction(ASTContext &Context, const FunctionDecl *FD, 249 const LangOptions &Features) { 250 // The kind of external linkage this function will have, if it is not 251 // inline or static. 252 CodeGenModule::GVALinkage External = CodeGenModule::GVA_StrongExternal; 253 if (Context.getLangOptions().CPlusPlus && 254 (FD->getPrimaryTemplate() || FD->getInstantiatedFromMemberFunction()) && 255 !FD->isExplicitSpecialization()) 256 External = CodeGenModule::GVA_TemplateInstantiation; 257 258 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) { 259 // C++ member functions defined inside the class are always inline. 260 if (MD->isInline() || !MD->isOutOfLine()) 261 return CodeGenModule::GVA_CXXInline; 262 263 return External; 264 } 265 266 // "static" functions get internal linkage. 267 if (FD->getStorageClass() == FunctionDecl::Static) 268 return CodeGenModule::GVA_Internal; 269 270 if (!FD->isInline()) 271 return External; 272 273 // If the inline function explicitly has the GNU inline attribute on it, or if 274 // this is C89 mode, we use to GNU semantics. 275 if (!Features.C99 && !Features.CPlusPlus) { 276 // extern inline in GNU mode is like C99 inline. 277 if (FD->getStorageClass() == FunctionDecl::Extern) 278 return CodeGenModule::GVA_C99Inline; 279 // Normal inline is a strong symbol. 280 return CodeGenModule::GVA_StrongExternal; 281 } else if (FD->hasActiveGNUInlineAttribute(Context)) { 282 // GCC in C99 mode seems to use a different decision-making 283 // process for extern inline, which factors in previous 284 // declarations. 285 if (FD->isExternGNUInline(Context)) 286 return CodeGenModule::GVA_C99Inline; 287 // Normal inline is a strong symbol. 288 return External; 289 } 290 291 // The definition of inline changes based on the language. Note that we 292 // have already handled "static inline" above, with the GVA_Internal case. 293 if (Features.CPlusPlus) // inline and extern inline. 294 return CodeGenModule::GVA_CXXInline; 295 296 assert(Features.C99 && "Must be in C99 mode if not in C89 or C++ mode"); 297 if (FD->isC99InlineDefinition()) 298 return CodeGenModule::GVA_C99Inline; 299 300 return CodeGenModule::GVA_StrongExternal; 301} 302 303/// SetFunctionDefinitionAttributes - Set attributes for a global. 304/// 305/// FIXME: This is currently only done for aliases and functions, but not for 306/// variables (these details are set in EmitGlobalVarDefinition for variables). 307void CodeGenModule::SetFunctionDefinitionAttributes(const FunctionDecl *D, 308 llvm::GlobalValue *GV) { 309 GVALinkage Linkage = GetLinkageForFunction(getContext(), D, Features); 310 311 if (Linkage == GVA_Internal) { 312 GV->setLinkage(llvm::Function::InternalLinkage); 313 } else if (D->hasAttr<DLLExportAttr>()) { 314 GV->setLinkage(llvm::Function::DLLExportLinkage); 315 } else if (D->hasAttr<WeakAttr>()) { 316 GV->setLinkage(llvm::Function::WeakAnyLinkage); 317 } else if (Linkage == GVA_C99Inline) { 318 // In C99 mode, 'inline' functions are guaranteed to have a strong 319 // definition somewhere else, so we can use available_externally linkage. 320 GV->setLinkage(llvm::Function::AvailableExternallyLinkage); 321 } else if (Linkage == GVA_CXXInline || Linkage == GVA_TemplateInstantiation) { 322 // In C++, the compiler has to emit a definition in every translation unit 323 // that references the function. We should use linkonce_odr because 324 // a) if all references in this translation unit are optimized away, we 325 // don't need to codegen it. b) if the function persists, it needs to be 326 // merged with other definitions. c) C++ has the ODR, so we know the 327 // definition is dependable. 328 GV->setLinkage(llvm::Function::LinkOnceODRLinkage); 329 } else { 330 assert(Linkage == GVA_StrongExternal); 331 // Otherwise, we have strong external linkage. 332 GV->setLinkage(llvm::Function::ExternalLinkage); 333 } 334 335 SetCommonAttributes(D, GV); 336} 337 338void CodeGenModule::SetLLVMFunctionAttributes(const Decl *D, 339 const CGFunctionInfo &Info, 340 llvm::Function *F) { 341 AttributeListType AttributeList; 342 ConstructAttributeList(Info, D, AttributeList); 343 344 F->setAttributes(llvm::AttrListPtr::get(AttributeList.begin(), 345 AttributeList.size())); 346 347 // Set the appropriate calling convention for the Function. 348 if (D->hasAttr<FastCallAttr>()) 349 F->setCallingConv(llvm::CallingConv::X86_FastCall); 350 351 if (D->hasAttr<StdCallAttr>()) 352 F->setCallingConv(llvm::CallingConv::X86_StdCall); 353} 354 355void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, 356 llvm::Function *F) { 357 if (!Features.Exceptions && !Features.ObjCNonFragileABI) 358 F->addFnAttr(llvm::Attribute::NoUnwind); 359 360 if (D->hasAttr<AlwaysInlineAttr>()) 361 F->addFnAttr(llvm::Attribute::AlwaysInline); 362 363 if (D->hasAttr<NoinlineAttr>()) 364 F->addFnAttr(llvm::Attribute::NoInline); 365} 366 367void CodeGenModule::SetCommonAttributes(const Decl *D, 368 llvm::GlobalValue *GV) { 369 setGlobalVisibility(GV, D); 370 371 if (D->hasAttr<UsedAttr>()) 372 AddUsedGlobal(GV); 373 374 if (const SectionAttr *SA = D->getAttr<SectionAttr>()) 375 GV->setSection(SA->getName()); 376} 377 378void CodeGenModule::SetInternalFunctionAttributes(const Decl *D, 379 llvm::Function *F, 380 const CGFunctionInfo &FI) { 381 SetLLVMFunctionAttributes(D, FI, F); 382 SetLLVMFunctionAttributesForDefinition(D, F); 383 384 F->setLinkage(llvm::Function::InternalLinkage); 385 386 SetCommonAttributes(D, F); 387} 388 389void CodeGenModule::SetFunctionAttributes(const FunctionDecl *FD, 390 llvm::Function *F, 391 bool IsIncompleteFunction) { 392 if (!IsIncompleteFunction) 393 SetLLVMFunctionAttributes(FD, getTypes().getFunctionInfo(FD), F); 394 395 // Only a few attributes are set on declarations; these may later be 396 // overridden by a definition. 397 398 if (FD->hasAttr<DLLImportAttr>()) { 399 F->setLinkage(llvm::Function::DLLImportLinkage); 400 } else if (FD->hasAttr<WeakAttr>() || 401 FD->hasAttr<WeakImportAttr>()) { 402 // "extern_weak" is overloaded in LLVM; we probably should have 403 // separate linkage types for this. 404 F->setLinkage(llvm::Function::ExternalWeakLinkage); 405 } else { 406 F->setLinkage(llvm::Function::ExternalLinkage); 407 } 408 409 if (const SectionAttr *SA = FD->getAttr<SectionAttr>()) 410 F->setSection(SA->getName()); 411} 412 413void CodeGenModule::AddUsedGlobal(llvm::GlobalValue *GV) { 414 assert(!GV->isDeclaration() && 415 "Only globals with definition can force usage."); 416 LLVMUsed.push_back(GV); 417} 418 419void CodeGenModule::EmitLLVMUsed() { 420 // Don't create llvm.used if there is no need. 421 if (LLVMUsed.empty()) 422 return; 423 424 llvm::Type *i8PTy = 425 llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext)); 426 427 // Convert LLVMUsed to what ConstantArray needs. 428 std::vector<llvm::Constant*> UsedArray; 429 UsedArray.resize(LLVMUsed.size()); 430 for (unsigned i = 0, e = LLVMUsed.size(); i != e; ++i) { 431 UsedArray[i] = 432 llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(&*LLVMUsed[i]), 433 i8PTy); 434 } 435 436 if (UsedArray.empty()) 437 return; 438 llvm::ArrayType *ATy = llvm::ArrayType::get(i8PTy, UsedArray.size()); 439 440 llvm::GlobalVariable *GV = 441 new llvm::GlobalVariable(getModule(), ATy, false, 442 llvm::GlobalValue::AppendingLinkage, 443 llvm::ConstantArray::get(ATy, UsedArray), 444 "llvm.used"); 445 446 GV->setSection("llvm.metadata"); 447} 448 449void CodeGenModule::EmitDeferred() { 450 // Emit code for any potentially referenced deferred decls. Since a 451 // previously unused static decl may become used during the generation of code 452 // for a static function, iterate until no changes are made. 453 while (!DeferredDeclsToEmit.empty()) { 454 GlobalDecl D = DeferredDeclsToEmit.back(); 455 DeferredDeclsToEmit.pop_back(); 456 457 // The mangled name for the decl must have been emitted in GlobalDeclMap. 458 // Look it up to see if it was defined with a stronger definition (e.g. an 459 // extern inline function with a strong function redefinition). If so, 460 // just ignore the deferred decl. 461 llvm::GlobalValue *CGRef = GlobalDeclMap[getMangledName(D)]; 462 assert(CGRef && "Deferred decl wasn't referenced?"); 463 464 if (!CGRef->isDeclaration()) 465 continue; 466 467 // Otherwise, emit the definition and move on to the next one. 468 EmitGlobalDefinition(D); 469 } 470} 471 472/// EmitAnnotateAttr - Generate the llvm::ConstantStruct which contains the 473/// annotation information for a given GlobalValue. The annotation struct is 474/// {i8 *, i8 *, i8 *, i32}. The first field is a constant expression, the 475/// GlobalValue being annotated. The second field is the constant string 476/// created from the AnnotateAttr's annotation. The third field is a constant 477/// string containing the name of the translation unit. The fourth field is 478/// the line number in the file of the annotated value declaration. 479/// 480/// FIXME: this does not unique the annotation string constants, as llvm-gcc 481/// appears to. 482/// 483llvm::Constant *CodeGenModule::EmitAnnotateAttr(llvm::GlobalValue *GV, 484 const AnnotateAttr *AA, 485 unsigned LineNo) { 486 llvm::Module *M = &getModule(); 487 488 // get [N x i8] constants for the annotation string, and the filename string 489 // which are the 2nd and 3rd elements of the global annotation structure. 490 const llvm::Type *SBP = 491 llvm::PointerType::getUnqual(llvm::Type::getInt8Ty(VMContext)); 492 llvm::Constant *anno = llvm::ConstantArray::get(VMContext, 493 AA->getAnnotation(), true); 494 llvm::Constant *unit = llvm::ConstantArray::get(VMContext, 495 M->getModuleIdentifier(), 496 true); 497 498 // Get the two global values corresponding to the ConstantArrays we just 499 // created to hold the bytes of the strings. 500 llvm::GlobalValue *annoGV = 501 new llvm::GlobalVariable(*M, anno->getType(), false, 502 llvm::GlobalValue::PrivateLinkage, anno, 503 GV->getName()); 504 // translation unit name string, emitted into the llvm.metadata section. 505 llvm::GlobalValue *unitGV = 506 new llvm::GlobalVariable(*M, unit->getType(), false, 507 llvm::GlobalValue::PrivateLinkage, unit, 508 ".str"); 509 510 // Create the ConstantStruct for the global annotation. 511 llvm::Constant *Fields[4] = { 512 llvm::ConstantExpr::getBitCast(GV, SBP), 513 llvm::ConstantExpr::getBitCast(annoGV, SBP), 514 llvm::ConstantExpr::getBitCast(unitGV, SBP), 515 llvm::ConstantInt::get(llvm::Type::getInt32Ty(VMContext), LineNo) 516 }; 517 return llvm::ConstantStruct::get(VMContext, Fields, 4, false); 518} 519 520bool CodeGenModule::MayDeferGeneration(const ValueDecl *Global) { 521 // Never defer when EmitAllDecls is specified or the decl has 522 // attribute used. 523 if (Features.EmitAllDecls || Global->hasAttr<UsedAttr>()) 524 return false; 525 526 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) { 527 // Constructors and destructors should never be deferred. 528 if (FD->hasAttr<ConstructorAttr>() || 529 FD->hasAttr<DestructorAttr>()) 530 return false; 531 532 GVALinkage Linkage = GetLinkageForFunction(getContext(), FD, Features); 533 534 // static, static inline, always_inline, and extern inline functions can 535 // always be deferred. Normal inline functions can be deferred in C99/C++. 536 if (Linkage == GVA_Internal || Linkage == GVA_C99Inline || 537 Linkage == GVA_CXXInline) 538 return true; 539 return false; 540 } 541 542 const VarDecl *VD = cast<VarDecl>(Global); 543 assert(VD->isFileVarDecl() && "Invalid decl"); 544 545 return VD->getStorageClass() == VarDecl::Static; 546} 547 548void CodeGenModule::EmitGlobal(GlobalDecl GD) { 549 const ValueDecl *Global = GD.getDecl(); 550 551 // If this is an alias definition (which otherwise looks like a declaration) 552 // emit it now. 553 if (Global->hasAttr<AliasAttr>()) 554 return EmitAliasDefinition(Global); 555 556 // Ignore declarations, they will be emitted on their first use. 557 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(Global)) { 558 // Forward declarations are emitted lazily on first use. 559 if (!FD->isThisDeclarationADefinition()) 560 return; 561 } else { 562 const VarDecl *VD = cast<VarDecl>(Global); 563 assert(VD->isFileVarDecl() && "Cannot emit local var decl as global."); 564 565 // In C++, if this is marked "extern", defer code generation. 566 if (getLangOptions().CPlusPlus && !VD->getInit() && 567 (VD->getStorageClass() == VarDecl::Extern || 568 VD->isExternC(getContext()))) 569 return; 570 571 // In C, if this isn't a definition, defer code generation. 572 if (!getLangOptions().CPlusPlus && !VD->getInit()) 573 return; 574 } 575 576 // Defer code generation when possible if this is a static definition, inline 577 // function etc. These we only want to emit if they are used. 578 if (MayDeferGeneration(Global)) { 579 // If the value has already been used, add it directly to the 580 // DeferredDeclsToEmit list. 581 const char *MangledName = getMangledName(GD); 582 if (GlobalDeclMap.count(MangledName)) 583 DeferredDeclsToEmit.push_back(GD); 584 else { 585 // Otherwise, remember that we saw a deferred decl with this name. The 586 // first use of the mangled name will cause it to move into 587 // DeferredDeclsToEmit. 588 DeferredDecls[MangledName] = GD; 589 } 590 return; 591 } 592 593 // Otherwise emit the definition. 594 EmitGlobalDefinition(GD); 595} 596 597void CodeGenModule::EmitGlobalDefinition(GlobalDecl GD) { 598 const ValueDecl *D = GD.getDecl(); 599 600 if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(D)) 601 EmitCXXConstructor(CD, GD.getCtorType()); 602 else if (const CXXDestructorDecl *DD = dyn_cast<CXXDestructorDecl>(D)) 603 EmitCXXDestructor(DD, GD.getDtorType()); 604 else if (isa<FunctionDecl>(D)) 605 EmitGlobalFunctionDefinition(GD); 606 else if (const VarDecl *VD = dyn_cast<VarDecl>(D)) 607 EmitGlobalVarDefinition(VD); 608 else { 609 assert(0 && "Invalid argument to EmitGlobalDefinition()"); 610 } 611} 612 613/// GetOrCreateLLVMFunction - If the specified mangled name is not in the 614/// module, create and return an llvm Function with the specified type. If there 615/// is something in the module with the specified name, return it potentially 616/// bitcasted to the right type. 617/// 618/// If D is non-null, it specifies a decl that correspond to this. This is used 619/// to set the attributes on the function when it is first created. 620llvm::Constant *CodeGenModule::GetOrCreateLLVMFunction(const char *MangledName, 621 const llvm::Type *Ty, 622 GlobalDecl D) { 623 // Lookup the entry, lazily creating it if necessary. 624 llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName]; 625 if (Entry) { 626 if (Entry->getType()->getElementType() == Ty) 627 return Entry; 628 629 // Make sure the result is of the correct type. 630 const llvm::Type *PTy = llvm::PointerType::getUnqual(Ty); 631 return llvm::ConstantExpr::getBitCast(Entry, PTy); 632 } 633 634 // This is the first use or definition of a mangled name. If there is a 635 // deferred decl with this name, remember that we need to emit it at the end 636 // of the file. 637 llvm::DenseMap<const char*, GlobalDecl>::iterator DDI = 638 DeferredDecls.find(MangledName); 639 if (DDI != DeferredDecls.end()) { 640 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 641 // list, and remove it from DeferredDecls (since we don't need it anymore). 642 DeferredDeclsToEmit.push_back(DDI->second); 643 DeferredDecls.erase(DDI); 644 } else if (const FunctionDecl *FD = cast_or_null<FunctionDecl>(D.getDecl())) { 645 // If this the first reference to a C++ inline function in a class, queue up 646 // the deferred function body for emission. These are not seen as 647 // top-level declarations. 648 if (FD->isThisDeclarationADefinition() && MayDeferGeneration(FD)) 649 DeferredDeclsToEmit.push_back(D); 650 // A called constructor which has no definition or declaration need be 651 // synthesized. 652 else if (const CXXConstructorDecl *CD = dyn_cast<CXXConstructorDecl>(FD)) { 653 const CXXRecordDecl *ClassDecl = 654 cast<CXXRecordDecl>(CD->getDeclContext()); 655 if (CD->isCopyConstructor(getContext())) 656 DeferredCopyConstructorToEmit(D); 657 else if (!ClassDecl->hasUserDeclaredConstructor()) 658 DeferredDeclsToEmit.push_back(D); 659 } 660 else if (isa<CXXDestructorDecl>(FD)) 661 DeferredDestructorToEmit(D); 662 else if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(FD)) 663 if (MD->isCopyAssignment()) 664 DeferredCopyAssignmentToEmit(D); 665 } 666 667 // This function doesn't have a complete type (for example, the return 668 // type is an incomplete struct). Use a fake type instead, and make 669 // sure not to try to set attributes. 670 bool IsIncompleteFunction = false; 671 if (!isa<llvm::FunctionType>(Ty)) { 672 Ty = llvm::FunctionType::get(llvm::Type::getVoidTy(VMContext), 673 std::vector<const llvm::Type*>(), false); 674 IsIncompleteFunction = true; 675 } 676 llvm::Function *F = llvm::Function::Create(cast<llvm::FunctionType>(Ty), 677 llvm::Function::ExternalLinkage, 678 "", &getModule()); 679 F->setName(MangledName); 680 if (D.getDecl()) 681 SetFunctionAttributes(cast<FunctionDecl>(D.getDecl()), F, 682 IsIncompleteFunction); 683 Entry = F; 684 return F; 685} 686 687/// Defer definition of copy constructor(s) which need be implicitly defined. 688void CodeGenModule::DeferredCopyConstructorToEmit(GlobalDecl CopyCtorDecl) { 689 const CXXConstructorDecl *CD = 690 cast<CXXConstructorDecl>(CopyCtorDecl.getDecl()); 691 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext()); 692 if (ClassDecl->hasTrivialCopyConstructor() || 693 ClassDecl->hasUserDeclaredCopyConstructor()) 694 return; 695 696 // First make sure all direct base classes and virtual bases and non-static 697 // data mebers which need to have their copy constructors implicitly defined 698 // are defined. 12.8.p7 699 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(); 700 Base != ClassDecl->bases_end(); ++Base) { 701 CXXRecordDecl *BaseClassDecl 702 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 703 if (CXXConstructorDecl *BaseCopyCtor = 704 BaseClassDecl->getCopyConstructor(Context, 0)) 705 GetAddrOfCXXConstructor(BaseCopyCtor, Ctor_Complete); 706 } 707 708 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 709 FieldEnd = ClassDecl->field_end(); 710 Field != FieldEnd; ++Field) { 711 QualType FieldType = Context.getCanonicalType((*Field)->getType()); 712 if (const ArrayType *Array = Context.getAsArrayType(FieldType)) 713 FieldType = Array->getElementType(); 714 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) { 715 if ((*Field)->isAnonymousStructOrUnion()) 716 continue; 717 CXXRecordDecl *FieldClassDecl 718 = cast<CXXRecordDecl>(FieldClassType->getDecl()); 719 if (CXXConstructorDecl *FieldCopyCtor = 720 FieldClassDecl->getCopyConstructor(Context, 0)) 721 GetAddrOfCXXConstructor(FieldCopyCtor, Ctor_Complete); 722 } 723 } 724 DeferredDeclsToEmit.push_back(CopyCtorDecl); 725} 726 727/// Defer definition of copy assignments which need be implicitly defined. 728void CodeGenModule::DeferredCopyAssignmentToEmit(GlobalDecl CopyAssignDecl) { 729 const CXXMethodDecl *CD = cast<CXXMethodDecl>(CopyAssignDecl.getDecl()); 730 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(CD->getDeclContext()); 731 732 if (ClassDecl->hasTrivialCopyAssignment() || 733 ClassDecl->hasUserDeclaredCopyAssignment()) 734 return; 735 736 // First make sure all direct base classes and virtual bases and non-static 737 // data mebers which need to have their copy assignments implicitly defined 738 // are defined. 12.8.p12 739 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(); 740 Base != ClassDecl->bases_end(); ++Base) { 741 CXXRecordDecl *BaseClassDecl 742 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 743 const CXXMethodDecl *MD = 0; 744 if (!BaseClassDecl->hasTrivialCopyAssignment() && 745 !BaseClassDecl->hasUserDeclaredCopyAssignment() && 746 BaseClassDecl->hasConstCopyAssignment(getContext(), MD)) 747 GetAddrOfFunction(GlobalDecl(MD), 0); 748 } 749 750 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 751 FieldEnd = ClassDecl->field_end(); 752 Field != FieldEnd; ++Field) { 753 QualType FieldType = Context.getCanonicalType((*Field)->getType()); 754 if (const ArrayType *Array = Context.getAsArrayType(FieldType)) 755 FieldType = Array->getElementType(); 756 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) { 757 if ((*Field)->isAnonymousStructOrUnion()) 758 continue; 759 CXXRecordDecl *FieldClassDecl 760 = cast<CXXRecordDecl>(FieldClassType->getDecl()); 761 const CXXMethodDecl *MD = 0; 762 if (!FieldClassDecl->hasTrivialCopyAssignment() && 763 !FieldClassDecl->hasUserDeclaredCopyAssignment() && 764 FieldClassDecl->hasConstCopyAssignment(getContext(), MD)) 765 GetAddrOfFunction(GlobalDecl(MD), 0); 766 } 767 } 768 DeferredDeclsToEmit.push_back(CopyAssignDecl); 769} 770 771void CodeGenModule::DeferredDestructorToEmit(GlobalDecl DtorDecl) { 772 const CXXDestructorDecl *DD = cast<CXXDestructorDecl>(DtorDecl.getDecl()); 773 const CXXRecordDecl *ClassDecl = cast<CXXRecordDecl>(DD->getDeclContext()); 774 if (ClassDecl->hasTrivialDestructor() || 775 ClassDecl->hasUserDeclaredDestructor()) 776 return; 777 778 for (CXXRecordDecl::base_class_const_iterator Base = ClassDecl->bases_begin(); 779 Base != ClassDecl->bases_end(); ++Base) { 780 CXXRecordDecl *BaseClassDecl 781 = cast<CXXRecordDecl>(Base->getType()->getAs<RecordType>()->getDecl()); 782 if (const CXXDestructorDecl *BaseDtor = 783 BaseClassDecl->getDestructor(Context)) 784 GetAddrOfCXXDestructor(BaseDtor, Dtor_Complete); 785 } 786 787 for (CXXRecordDecl::field_iterator Field = ClassDecl->field_begin(), 788 FieldEnd = ClassDecl->field_end(); 789 Field != FieldEnd; ++Field) { 790 QualType FieldType = Context.getCanonicalType((*Field)->getType()); 791 if (const ArrayType *Array = Context.getAsArrayType(FieldType)) 792 FieldType = Array->getElementType(); 793 if (const RecordType *FieldClassType = FieldType->getAs<RecordType>()) { 794 if ((*Field)->isAnonymousStructOrUnion()) 795 continue; 796 CXXRecordDecl *FieldClassDecl 797 = cast<CXXRecordDecl>(FieldClassType->getDecl()); 798 if (const CXXDestructorDecl *FieldDtor = 799 FieldClassDecl->getDestructor(Context)) 800 GetAddrOfCXXDestructor(FieldDtor, Dtor_Complete); 801 } 802 } 803 DeferredDeclsToEmit.push_back(DtorDecl); 804} 805 806 807/// GetAddrOfFunction - Return the address of the given function. If Ty is 808/// non-null, then this function will use the specified type if it has to 809/// create it (this occurs when we see a definition of the function). 810llvm::Constant *CodeGenModule::GetAddrOfFunction(GlobalDecl GD, 811 const llvm::Type *Ty) { 812 // If there was no specific requested type, just convert it now. 813 if (!Ty) 814 Ty = getTypes().ConvertType(GD.getDecl()->getType()); 815 return GetOrCreateLLVMFunction(getMangledName(GD.getDecl()), Ty, GD); 816} 817 818/// CreateRuntimeFunction - Create a new runtime function with the specified 819/// type and name. 820llvm::Constant * 821CodeGenModule::CreateRuntimeFunction(const llvm::FunctionType *FTy, 822 const char *Name) { 823 // Convert Name to be a uniqued string from the IdentifierInfo table. 824 Name = getContext().Idents.get(Name).getName(); 825 return GetOrCreateLLVMFunction(Name, FTy, GlobalDecl()); 826} 827 828/// GetOrCreateLLVMGlobal - If the specified mangled name is not in the module, 829/// create and return an llvm GlobalVariable with the specified type. If there 830/// is something in the module with the specified name, return it potentially 831/// bitcasted to the right type. 832/// 833/// If D is non-null, it specifies a decl that correspond to this. This is used 834/// to set the attributes on the global when it is first created. 835llvm::Constant *CodeGenModule::GetOrCreateLLVMGlobal(const char *MangledName, 836 const llvm::PointerType*Ty, 837 const VarDecl *D) { 838 // Lookup the entry, lazily creating it if necessary. 839 llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName]; 840 if (Entry) { 841 if (Entry->getType() == Ty) 842 return Entry; 843 844 // Make sure the result is of the correct type. 845 return llvm::ConstantExpr::getBitCast(Entry, Ty); 846 } 847 848 // This is the first use or definition of a mangled name. If there is a 849 // deferred decl with this name, remember that we need to emit it at the end 850 // of the file. 851 llvm::DenseMap<const char*, GlobalDecl>::iterator DDI = 852 DeferredDecls.find(MangledName); 853 if (DDI != DeferredDecls.end()) { 854 // Move the potentially referenced deferred decl to the DeferredDeclsToEmit 855 // list, and remove it from DeferredDecls (since we don't need it anymore). 856 DeferredDeclsToEmit.push_back(DDI->second); 857 DeferredDecls.erase(DDI); 858 } 859 860 llvm::GlobalVariable *GV = 861 new llvm::GlobalVariable(getModule(), Ty->getElementType(), false, 862 llvm::GlobalValue::ExternalLinkage, 863 0, "", 0, 864 false, Ty->getAddressSpace()); 865 GV->setName(MangledName); 866 867 // Handle things which are present even on external declarations. 868 if (D) { 869 // FIXME: This code is overly simple and should be merged with other global 870 // handling. 871 GV->setConstant(D->getType().isConstant(Context)); 872 873 // FIXME: Merge with other attribute handling code. 874 if (D->getStorageClass() == VarDecl::PrivateExtern) 875 GV->setVisibility(llvm::GlobalValue::HiddenVisibility); 876 877 if (D->hasAttr<WeakAttr>() || 878 D->hasAttr<WeakImportAttr>()) 879 GV->setLinkage(llvm::GlobalValue::ExternalWeakLinkage); 880 881 GV->setThreadLocal(D->isThreadSpecified()); 882 } 883 884 return Entry = GV; 885} 886 887 888/// GetAddrOfGlobalVar - Return the llvm::Constant for the address of the 889/// given global variable. If Ty is non-null and if the global doesn't exist, 890/// then it will be greated with the specified type instead of whatever the 891/// normal requested type would be. 892llvm::Constant *CodeGenModule::GetAddrOfGlobalVar(const VarDecl *D, 893 const llvm::Type *Ty) { 894 assert(D->hasGlobalStorage() && "Not a global variable"); 895 QualType ASTTy = D->getType(); 896 if (Ty == 0) 897 Ty = getTypes().ConvertTypeForMem(ASTTy); 898 899 const llvm::PointerType *PTy = 900 llvm::PointerType::get(Ty, ASTTy.getAddressSpace()); 901 return GetOrCreateLLVMGlobal(getMangledName(D), PTy, D); 902} 903 904/// CreateRuntimeVariable - Create a new runtime global variable with the 905/// specified type and name. 906llvm::Constant * 907CodeGenModule::CreateRuntimeVariable(const llvm::Type *Ty, 908 const char *Name) { 909 // Convert Name to be a uniqued string from the IdentifierInfo table. 910 Name = getContext().Idents.get(Name).getName(); 911 return GetOrCreateLLVMGlobal(Name, llvm::PointerType::getUnqual(Ty), 0); 912} 913 914void CodeGenModule::EmitTentativeDefinition(const VarDecl *D) { 915 assert(!D->getInit() && "Cannot emit definite definitions here!"); 916 917 if (MayDeferGeneration(D)) { 918 // If we have not seen a reference to this variable yet, place it 919 // into the deferred declarations table to be emitted if needed 920 // later. 921 const char *MangledName = getMangledName(D); 922 if (GlobalDeclMap.count(MangledName) == 0) { 923 DeferredDecls[MangledName] = GlobalDecl(D); 924 return; 925 } 926 } 927 928 // The tentative definition is the only definition. 929 EmitGlobalVarDefinition(D); 930} 931 932void CodeGenModule::EmitGlobalVarDefinition(const VarDecl *D) { 933 llvm::Constant *Init = 0; 934 QualType ASTTy = D->getType(); 935 936 if (D->getInit() == 0) { 937 // This is a tentative definition; tentative definitions are 938 // implicitly initialized with { 0 }. 939 // 940 // Note that tentative definitions are only emitted at the end of 941 // a translation unit, so they should never have incomplete 942 // type. In addition, EmitTentativeDefinition makes sure that we 943 // never attempt to emit a tentative definition if a real one 944 // exists. A use may still exists, however, so we still may need 945 // to do a RAUW. 946 assert(!ASTTy->isIncompleteType() && "Unexpected incomplete type"); 947 Init = EmitNullConstant(D->getType()); 948 } else { 949 Init = EmitConstantExpr(D->getInit(), D->getType()); 950 951 if (!Init) { 952 QualType T = D->getInit()->getType(); 953 if (getLangOptions().CPlusPlus) { 954 CXXGlobalInits.push_back(D); 955 Init = EmitNullConstant(T); 956 } else { 957 ErrorUnsupported(D, "static initializer"); 958 Init = llvm::UndefValue::get(getTypes().ConvertType(T)); 959 } 960 } 961 } 962 963 const llvm::Type* InitType = Init->getType(); 964 llvm::Constant *Entry = GetAddrOfGlobalVar(D, InitType); 965 966 // Strip off a bitcast if we got one back. 967 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 968 assert(CE->getOpcode() == llvm::Instruction::BitCast || 969 // all zero index gep. 970 CE->getOpcode() == llvm::Instruction::GetElementPtr); 971 Entry = CE->getOperand(0); 972 } 973 974 // Entry is now either a Function or GlobalVariable. 975 llvm::GlobalVariable *GV = dyn_cast<llvm::GlobalVariable>(Entry); 976 977 // We have a definition after a declaration with the wrong type. 978 // We must make a new GlobalVariable* and update everything that used OldGV 979 // (a declaration or tentative definition) with the new GlobalVariable* 980 // (which will be a definition). 981 // 982 // This happens if there is a prototype for a global (e.g. 983 // "extern int x[];") and then a definition of a different type (e.g. 984 // "int x[10];"). This also happens when an initializer has a different type 985 // from the type of the global (this happens with unions). 986 if (GV == 0 || 987 GV->getType()->getElementType() != InitType || 988 GV->getType()->getAddressSpace() != ASTTy.getAddressSpace()) { 989 990 // Remove the old entry from GlobalDeclMap so that we'll create a new one. 991 GlobalDeclMap.erase(getMangledName(D)); 992 993 // Make a new global with the correct type, this is now guaranteed to work. 994 GV = cast<llvm::GlobalVariable>(GetAddrOfGlobalVar(D, InitType)); 995 GV->takeName(cast<llvm::GlobalValue>(Entry)); 996 997 // Replace all uses of the old global with the new global 998 llvm::Constant *NewPtrForOldDecl = 999 llvm::ConstantExpr::getBitCast(GV, Entry->getType()); 1000 Entry->replaceAllUsesWith(NewPtrForOldDecl); 1001 1002 // Erase the old global, since it is no longer used. 1003 cast<llvm::GlobalValue>(Entry)->eraseFromParent(); 1004 } 1005 1006 if (const AnnotateAttr *AA = D->getAttr<AnnotateAttr>()) { 1007 SourceManager &SM = Context.getSourceManager(); 1008 AddAnnotation(EmitAnnotateAttr(GV, AA, 1009 SM.getInstantiationLineNumber(D->getLocation()))); 1010 } 1011 1012 GV->setInitializer(Init); 1013 1014 // If it is safe to mark the global 'constant', do so now. 1015 GV->setConstant(false); 1016 if (D->getType().isConstant(Context)) { 1017 // FIXME: In C++, if the variable has a non-trivial ctor/dtor or any mutable 1018 // members, it cannot be declared "LLVM const". 1019 GV->setConstant(true); 1020 } 1021 1022 GV->setAlignment(getContext().getDeclAlignInBytes(D)); 1023 1024 // Set the llvm linkage type as appropriate. 1025 if (D->getStorageClass() == VarDecl::Static) 1026 GV->setLinkage(llvm::Function::InternalLinkage); 1027 else if (D->hasAttr<DLLImportAttr>()) 1028 GV->setLinkage(llvm::Function::DLLImportLinkage); 1029 else if (D->hasAttr<DLLExportAttr>()) 1030 GV->setLinkage(llvm::Function::DLLExportLinkage); 1031 else if (D->hasAttr<WeakAttr>()) { 1032 if (GV->isConstant()) 1033 GV->setLinkage(llvm::GlobalVariable::WeakODRLinkage); 1034 else 1035 GV->setLinkage(llvm::GlobalVariable::WeakAnyLinkage); 1036 } else if (!CompileOpts.NoCommon && 1037 !D->hasExternalStorage() && !D->getInit() && 1038 !D->getAttr<SectionAttr>()) { 1039 GV->setLinkage(llvm::GlobalVariable::CommonLinkage); 1040 // common vars aren't constant even if declared const. 1041 GV->setConstant(false); 1042 } else 1043 GV->setLinkage(llvm::GlobalVariable::ExternalLinkage); 1044 1045 SetCommonAttributes(D, GV); 1046 1047 // Emit global variable debug information. 1048 if (CGDebugInfo *DI = getDebugInfo()) { 1049 DI->setLocation(D->getLocation()); 1050 DI->EmitGlobalVariable(GV, D); 1051 } 1052} 1053 1054/// ReplaceUsesOfNonProtoTypeWithRealFunction - This function is called when we 1055/// implement a function with no prototype, e.g. "int foo() {}". If there are 1056/// existing call uses of the old function in the module, this adjusts them to 1057/// call the new function directly. 1058/// 1059/// This is not just a cleanup: the always_inline pass requires direct calls to 1060/// functions to be able to inline them. If there is a bitcast in the way, it 1061/// won't inline them. Instcombine normally deletes these calls, but it isn't 1062/// run at -O0. 1063static void ReplaceUsesOfNonProtoTypeWithRealFunction(llvm::GlobalValue *Old, 1064 llvm::Function *NewFn) { 1065 // If we're redefining a global as a function, don't transform it. 1066 llvm::Function *OldFn = dyn_cast<llvm::Function>(Old); 1067 if (OldFn == 0) return; 1068 1069 const llvm::Type *NewRetTy = NewFn->getReturnType(); 1070 llvm::SmallVector<llvm::Value*, 4> ArgList; 1071 1072 for (llvm::Value::use_iterator UI = OldFn->use_begin(), E = OldFn->use_end(); 1073 UI != E; ) { 1074 // TODO: Do invokes ever occur in C code? If so, we should handle them too. 1075 unsigned OpNo = UI.getOperandNo(); 1076 llvm::CallInst *CI = dyn_cast<llvm::CallInst>(*UI++); 1077 if (!CI || OpNo != 0) continue; 1078 1079 // If the return types don't match exactly, and if the call isn't dead, then 1080 // we can't transform this call. 1081 if (CI->getType() != NewRetTy && !CI->use_empty()) 1082 continue; 1083 1084 // If the function was passed too few arguments, don't transform. If extra 1085 // arguments were passed, we silently drop them. If any of the types 1086 // mismatch, we don't transform. 1087 unsigned ArgNo = 0; 1088 bool DontTransform = false; 1089 for (llvm::Function::arg_iterator AI = NewFn->arg_begin(), 1090 E = NewFn->arg_end(); AI != E; ++AI, ++ArgNo) { 1091 if (CI->getNumOperands()-1 == ArgNo || 1092 CI->getOperand(ArgNo+1)->getType() != AI->getType()) { 1093 DontTransform = true; 1094 break; 1095 } 1096 } 1097 if (DontTransform) 1098 continue; 1099 1100 // Okay, we can transform this. Create the new call instruction and copy 1101 // over the required information. 1102 ArgList.append(CI->op_begin()+1, CI->op_begin()+1+ArgNo); 1103 llvm::CallInst *NewCall = llvm::CallInst::Create(NewFn, ArgList.begin(), 1104 ArgList.end(), "", CI); 1105 ArgList.clear(); 1106 if (NewCall->getType() != llvm::Type::getVoidTy(Old->getContext())) 1107 NewCall->takeName(CI); 1108 NewCall->setCallingConv(CI->getCallingConv()); 1109 NewCall->setAttributes(CI->getAttributes()); 1110 1111 // Finally, remove the old call, replacing any uses with the new one. 1112 if (!CI->use_empty()) 1113 CI->replaceAllUsesWith(NewCall); 1114 CI->eraseFromParent(); 1115 } 1116} 1117 1118 1119void CodeGenModule::EmitGlobalFunctionDefinition(GlobalDecl GD) { 1120 const llvm::FunctionType *Ty; 1121 const FunctionDecl *D = cast<FunctionDecl>(GD.getDecl()); 1122 1123 if (const CXXMethodDecl *MD = dyn_cast<CXXMethodDecl>(D)) { 1124 bool isVariadic = D->getType()->getAsFunctionProtoType()->isVariadic(); 1125 1126 Ty = getTypes().GetFunctionType(getTypes().getFunctionInfo(MD), isVariadic); 1127 } else { 1128 Ty = cast<llvm::FunctionType>(getTypes().ConvertType(D->getType())); 1129 1130 // As a special case, make sure that definitions of K&R function 1131 // "type foo()" aren't declared as varargs (which forces the backend 1132 // to do unnecessary work). 1133 if (D->getType()->isFunctionNoProtoType()) { 1134 assert(Ty->isVarArg() && "Didn't lower type as expected"); 1135 // Due to stret, the lowered function could have arguments. 1136 // Just create the same type as was lowered by ConvertType 1137 // but strip off the varargs bit. 1138 std::vector<const llvm::Type*> Args(Ty->param_begin(), Ty->param_end()); 1139 Ty = llvm::FunctionType::get(Ty->getReturnType(), Args, false); 1140 } 1141 } 1142 1143 // Get or create the prototype for the function. 1144 llvm::Constant *Entry = GetAddrOfFunction(GD, Ty); 1145 1146 // Strip off a bitcast if we got one back. 1147 if (llvm::ConstantExpr *CE = dyn_cast<llvm::ConstantExpr>(Entry)) { 1148 assert(CE->getOpcode() == llvm::Instruction::BitCast); 1149 Entry = CE->getOperand(0); 1150 } 1151 1152 1153 if (cast<llvm::GlobalValue>(Entry)->getType()->getElementType() != Ty) { 1154 llvm::GlobalValue *OldFn = cast<llvm::GlobalValue>(Entry); 1155 1156 // If the types mismatch then we have to rewrite the definition. 1157 assert(OldFn->isDeclaration() && 1158 "Shouldn't replace non-declaration"); 1159 1160 // F is the Function* for the one with the wrong type, we must make a new 1161 // Function* and update everything that used F (a declaration) with the new 1162 // Function* (which will be a definition). 1163 // 1164 // This happens if there is a prototype for a function 1165 // (e.g. "int f()") and then a definition of a different type 1166 // (e.g. "int f(int x)"). Start by making a new function of the 1167 // correct type, RAUW, then steal the name. 1168 GlobalDeclMap.erase(getMangledName(D)); 1169 llvm::Function *NewFn = cast<llvm::Function>(GetAddrOfFunction(GD, Ty)); 1170 NewFn->takeName(OldFn); 1171 1172 // If this is an implementation of a function without a prototype, try to 1173 // replace any existing uses of the function (which may be calls) with uses 1174 // of the new function 1175 if (D->getType()->isFunctionNoProtoType()) { 1176 ReplaceUsesOfNonProtoTypeWithRealFunction(OldFn, NewFn); 1177 OldFn->removeDeadConstantUsers(); 1178 } 1179 1180 // Replace uses of F with the Function we will endow with a body. 1181 if (!Entry->use_empty()) { 1182 llvm::Constant *NewPtrForOldDecl = 1183 llvm::ConstantExpr::getBitCast(NewFn, Entry->getType()); 1184 Entry->replaceAllUsesWith(NewPtrForOldDecl); 1185 } 1186 1187 // Ok, delete the old function now, which is dead. 1188 OldFn->eraseFromParent(); 1189 1190 Entry = NewFn; 1191 } 1192 1193 llvm::Function *Fn = cast<llvm::Function>(Entry); 1194 1195 CodeGenFunction(*this).GenerateCode(D, Fn); 1196 1197 SetFunctionDefinitionAttributes(D, Fn); 1198 SetLLVMFunctionAttributesForDefinition(D, Fn); 1199 1200 if (const ConstructorAttr *CA = D->getAttr<ConstructorAttr>()) 1201 AddGlobalCtor(Fn, CA->getPriority()); 1202 if (const DestructorAttr *DA = D->getAttr<DestructorAttr>()) 1203 AddGlobalDtor(Fn, DA->getPriority()); 1204} 1205 1206void CodeGenModule::EmitAliasDefinition(const ValueDecl *D) { 1207 const AliasAttr *AA = D->getAttr<AliasAttr>(); 1208 assert(AA && "Not an alias?"); 1209 1210 const llvm::Type *DeclTy = getTypes().ConvertTypeForMem(D->getType()); 1211 1212 // Unique the name through the identifier table. 1213 const char *AliaseeName = AA->getAliasee().c_str(); 1214 AliaseeName = getContext().Idents.get(AliaseeName).getName(); 1215 1216 // Create a reference to the named value. This ensures that it is emitted 1217 // if a deferred decl. 1218 llvm::Constant *Aliasee; 1219 if (isa<llvm::FunctionType>(DeclTy)) 1220 Aliasee = GetOrCreateLLVMFunction(AliaseeName, DeclTy, GlobalDecl()); 1221 else 1222 Aliasee = GetOrCreateLLVMGlobal(AliaseeName, 1223 llvm::PointerType::getUnqual(DeclTy), 0); 1224 1225 // Create the new alias itself, but don't set a name yet. 1226 llvm::GlobalValue *GA = 1227 new llvm::GlobalAlias(Aliasee->getType(), 1228 llvm::Function::ExternalLinkage, 1229 "", Aliasee, &getModule()); 1230 1231 // See if there is already something with the alias' name in the module. 1232 const char *MangledName = getMangledName(D); 1233 llvm::GlobalValue *&Entry = GlobalDeclMap[MangledName]; 1234 1235 if (Entry && !Entry->isDeclaration()) { 1236 // If there is a definition in the module, then it wins over the alias. 1237 // This is dubious, but allow it to be safe. Just ignore the alias. 1238 GA->eraseFromParent(); 1239 return; 1240 } 1241 1242 if (Entry) { 1243 // If there is a declaration in the module, then we had an extern followed 1244 // by the alias, as in: 1245 // extern int test6(); 1246 // ... 1247 // int test6() __attribute__((alias("test7"))); 1248 // 1249 // Remove it and replace uses of it with the alias. 1250 1251 Entry->replaceAllUsesWith(llvm::ConstantExpr::getBitCast(GA, 1252 Entry->getType())); 1253 Entry->eraseFromParent(); 1254 } 1255 1256 // Now we know that there is no conflict, set the name. 1257 Entry = GA; 1258 GA->setName(MangledName); 1259 1260 // Set attributes which are particular to an alias; this is a 1261 // specialization of the attributes which may be set on a global 1262 // variable/function. 1263 if (D->hasAttr<DLLExportAttr>()) { 1264 if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) { 1265 // The dllexport attribute is ignored for undefined symbols. 1266 if (FD->getBody()) 1267 GA->setLinkage(llvm::Function::DLLExportLinkage); 1268 } else { 1269 GA->setLinkage(llvm::Function::DLLExportLinkage); 1270 } 1271 } else if (D->hasAttr<WeakAttr>() || 1272 D->hasAttr<WeakImportAttr>()) { 1273 GA->setLinkage(llvm::Function::WeakAnyLinkage); 1274 } 1275 1276 SetCommonAttributes(D, GA); 1277} 1278 1279/// getBuiltinLibFunction - Given a builtin id for a function like 1280/// "__builtin_fabsf", return a Function* for "fabsf". 1281llvm::Value *CodeGenModule::getBuiltinLibFunction(unsigned BuiltinID) { 1282 assert((Context.BuiltinInfo.isLibFunction(BuiltinID) || 1283 Context.BuiltinInfo.isPredefinedLibFunction(BuiltinID)) && 1284 "isn't a lib fn"); 1285 1286 // Get the name, skip over the __builtin_ prefix (if necessary). 1287 const char *Name = Context.BuiltinInfo.GetName(BuiltinID); 1288 if (Context.BuiltinInfo.isLibFunction(BuiltinID)) 1289 Name += 10; 1290 1291 // Get the type for the builtin. 1292 ASTContext::GetBuiltinTypeError Error; 1293 QualType Type = Context.GetBuiltinType(BuiltinID, Error); 1294 assert(Error == ASTContext::GE_None && "Can't get builtin type"); 1295 1296 const llvm::FunctionType *Ty = 1297 cast<llvm::FunctionType>(getTypes().ConvertType(Type)); 1298 1299 // Unique the name through the identifier table. 1300 Name = getContext().Idents.get(Name).getName(); 1301 // FIXME: param attributes for sext/zext etc. 1302 return GetOrCreateLLVMFunction(Name, Ty, GlobalDecl()); 1303} 1304 1305llvm::Function *CodeGenModule::getIntrinsic(unsigned IID,const llvm::Type **Tys, 1306 unsigned NumTys) { 1307 return llvm::Intrinsic::getDeclaration(&getModule(), 1308 (llvm::Intrinsic::ID)IID, Tys, NumTys); 1309} 1310 1311llvm::Function *CodeGenModule::getMemCpyFn() { 1312 if (MemCpyFn) return MemCpyFn; 1313 const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext); 1314 return MemCpyFn = getIntrinsic(llvm::Intrinsic::memcpy, &IntPtr, 1); 1315} 1316 1317llvm::Function *CodeGenModule::getMemMoveFn() { 1318 if (MemMoveFn) return MemMoveFn; 1319 const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext); 1320 return MemMoveFn = getIntrinsic(llvm::Intrinsic::memmove, &IntPtr, 1); 1321} 1322 1323llvm::Function *CodeGenModule::getMemSetFn() { 1324 if (MemSetFn) return MemSetFn; 1325 const llvm::Type *IntPtr = TheTargetData.getIntPtrType(VMContext); 1326 return MemSetFn = getIntrinsic(llvm::Intrinsic::memset, &IntPtr, 1); 1327} 1328 1329static llvm::StringMapEntry<llvm::Constant*> & 1330GetConstantCFStringEntry(llvm::StringMap<llvm::Constant*> &Map, 1331 const StringLiteral *Literal, 1332 bool TargetIsLSB, 1333 bool &IsUTF16, 1334 unsigned &StringLength) { 1335 unsigned NumBytes = Literal->getByteLength(); 1336 1337 // Check for simple case. 1338 if (!Literal->containsNonAsciiOrNull()) { 1339 StringLength = NumBytes; 1340 return Map.GetOrCreateValue(llvm::StringRef(Literal->getStrData(), 1341 StringLength)); 1342 } 1343 1344 // Otherwise, convert the UTF8 literals into a byte string. 1345 llvm::SmallVector<UTF16, 128> ToBuf(NumBytes); 1346 const UTF8 *FromPtr = (UTF8 *)Literal->getStrData(); 1347 UTF16 *ToPtr = &ToBuf[0]; 1348 1349 ConversionResult Result = ConvertUTF8toUTF16(&FromPtr, FromPtr + NumBytes, 1350 &ToPtr, ToPtr + NumBytes, 1351 strictConversion); 1352 1353 // Check for conversion failure. 1354 if (Result != conversionOK) { 1355 // FIXME: Have Sema::CheckObjCString() validate the UTF-8 string and remove 1356 // this duplicate code. 1357 assert(Result == sourceIllegal && "UTF-8 to UTF-16 conversion failed"); 1358 StringLength = NumBytes; 1359 return Map.GetOrCreateValue(llvm::StringRef(Literal->getStrData(), 1360 StringLength)); 1361 } 1362 1363 // ConvertUTF8toUTF16 returns the length in ToPtr. 1364 StringLength = ToPtr - &ToBuf[0]; 1365 1366 // Render the UTF-16 string into a byte array and convert to the target byte 1367 // order. 1368 // 1369 // FIXME: This isn't something we should need to do here. 1370 llvm::SmallString<128> AsBytes; 1371 AsBytes.reserve(StringLength * 2); 1372 for (unsigned i = 0; i != StringLength; ++i) { 1373 unsigned short Val = ToBuf[i]; 1374 if (TargetIsLSB) { 1375 AsBytes.push_back(Val & 0xFF); 1376 AsBytes.push_back(Val >> 8); 1377 } else { 1378 AsBytes.push_back(Val >> 8); 1379 AsBytes.push_back(Val & 0xFF); 1380 } 1381 } 1382 // Append one extra null character, the second is automatically added by our 1383 // caller. 1384 AsBytes.push_back(0); 1385 1386 IsUTF16 = true; 1387 return Map.GetOrCreateValue(llvm::StringRef(AsBytes.data(), AsBytes.size())); 1388} 1389 1390llvm::Constant * 1391CodeGenModule::GetAddrOfConstantCFString(const StringLiteral *Literal) { 1392 unsigned StringLength = 0; 1393 bool isUTF16 = false; 1394 llvm::StringMapEntry<llvm::Constant*> &Entry = 1395 GetConstantCFStringEntry(CFConstantStringMap, Literal, 1396 getTargetData().isLittleEndian(), 1397 isUTF16, StringLength); 1398 1399 if (llvm::Constant *C = Entry.getValue()) 1400 return C; 1401 1402 llvm::Constant *Zero = 1403 llvm::Constant::getNullValue(llvm::Type::getInt32Ty(VMContext)); 1404 llvm::Constant *Zeros[] = { Zero, Zero }; 1405 1406 // If we don't already have it, get __CFConstantStringClassReference. 1407 if (!CFConstantStringClassRef) { 1408 const llvm::Type *Ty = getTypes().ConvertType(getContext().IntTy); 1409 Ty = llvm::ArrayType::get(Ty, 0); 1410 llvm::Constant *GV = CreateRuntimeVariable(Ty, 1411 "__CFConstantStringClassReference"); 1412 // Decay array -> ptr 1413 CFConstantStringClassRef = 1414 llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1415 } 1416 1417 QualType CFTy = getContext().getCFConstantStringType(); 1418 1419 const llvm::StructType *STy = 1420 cast<llvm::StructType>(getTypes().ConvertType(CFTy)); 1421 1422 std::vector<llvm::Constant*> Fields(4); 1423 1424 // Class pointer. 1425 Fields[0] = CFConstantStringClassRef; 1426 1427 // Flags. 1428 const llvm::Type *Ty = getTypes().ConvertType(getContext().UnsignedIntTy); 1429 Fields[1] = isUTF16 ? llvm::ConstantInt::get(Ty, 0x07d0) : 1430 llvm::ConstantInt::get(Ty, 0x07C8); 1431 1432 // String pointer. 1433 llvm::Constant *C = llvm::ConstantArray::get(VMContext, Entry.getKey().str()); 1434 1435 const char *Sect, *Prefix; 1436 bool isConstant; 1437 llvm::GlobalValue::LinkageTypes Linkage; 1438 if (isUTF16) { 1439 Prefix = getContext().Target.getUnicodeStringSymbolPrefix(); 1440 Sect = getContext().Target.getUnicodeStringSection(); 1441 // FIXME: why do utf strings get "l" labels instead of "L" labels? 1442 Linkage = llvm::GlobalValue::InternalLinkage; 1443 // FIXME: Why does GCC not set constant here? 1444 isConstant = false; 1445 } else { 1446 Prefix = ".str"; 1447 Sect = getContext().Target.getCFStringDataSection(); 1448 Linkage = llvm::GlobalValue::PrivateLinkage; 1449 // FIXME: -fwritable-strings should probably affect this, but we 1450 // are following gcc here. 1451 isConstant = true; 1452 } 1453 llvm::GlobalVariable *GV = 1454 new llvm::GlobalVariable(getModule(), C->getType(), isConstant, 1455 Linkage, C, Prefix); 1456 if (Sect) 1457 GV->setSection(Sect); 1458 if (isUTF16) { 1459 unsigned Align = getContext().getTypeAlign(getContext().ShortTy)/8; 1460 GV->setAlignment(Align); 1461 } 1462 Fields[2] = llvm::ConstantExpr::getGetElementPtr(GV, Zeros, 2); 1463 1464 // String length. 1465 Ty = getTypes().ConvertType(getContext().LongTy); 1466 Fields[3] = llvm::ConstantInt::get(Ty, StringLength); 1467 1468 // The struct. 1469 C = llvm::ConstantStruct::get(STy, Fields); 1470 GV = new llvm::GlobalVariable(getModule(), C->getType(), true, 1471 llvm::GlobalVariable::PrivateLinkage, C, 1472 "_unnamed_cfstring_"); 1473 if (const char *Sect = getContext().Target.getCFStringSection()) 1474 GV->setSection(Sect); 1475 Entry.setValue(GV); 1476 1477 return GV; 1478} 1479 1480/// GetStringForStringLiteral - Return the appropriate bytes for a 1481/// string literal, properly padded to match the literal type. 1482std::string CodeGenModule::GetStringForStringLiteral(const StringLiteral *E) { 1483 const char *StrData = E->getStrData(); 1484 unsigned Len = E->getByteLength(); 1485 1486 const ConstantArrayType *CAT = 1487 getContext().getAsConstantArrayType(E->getType()); 1488 assert(CAT && "String isn't pointer or array!"); 1489 1490 // Resize the string to the right size. 1491 std::string Str(StrData, StrData+Len); 1492 uint64_t RealLen = CAT->getSize().getZExtValue(); 1493 1494 if (E->isWide()) 1495 RealLen *= getContext().Target.getWCharWidth()/8; 1496 1497 Str.resize(RealLen, '\0'); 1498 1499 return Str; 1500} 1501 1502/// GetAddrOfConstantStringFromLiteral - Return a pointer to a 1503/// constant array for the given string literal. 1504llvm::Constant * 1505CodeGenModule::GetAddrOfConstantStringFromLiteral(const StringLiteral *S) { 1506 // FIXME: This can be more efficient. 1507 return GetAddrOfConstantString(GetStringForStringLiteral(S)); 1508} 1509 1510/// GetAddrOfConstantStringFromObjCEncode - Return a pointer to a constant 1511/// array for the given ObjCEncodeExpr node. 1512llvm::Constant * 1513CodeGenModule::GetAddrOfConstantStringFromObjCEncode(const ObjCEncodeExpr *E) { 1514 std::string Str; 1515 getContext().getObjCEncodingForType(E->getEncodedType(), Str); 1516 1517 return GetAddrOfConstantCString(Str); 1518} 1519 1520 1521/// GenerateWritableString -- Creates storage for a string literal. 1522static llvm::Constant *GenerateStringLiteral(const std::string &str, 1523 bool constant, 1524 CodeGenModule &CGM, 1525 const char *GlobalName) { 1526 // Create Constant for this string literal. Don't add a '\0'. 1527 llvm::Constant *C = 1528 llvm::ConstantArray::get(CGM.getLLVMContext(), str, false); 1529 1530 // Create a global variable for this string 1531 return new llvm::GlobalVariable(CGM.getModule(), C->getType(), constant, 1532 llvm::GlobalValue::PrivateLinkage, 1533 C, GlobalName); 1534} 1535 1536/// GetAddrOfConstantString - Returns a pointer to a character array 1537/// containing the literal. This contents are exactly that of the 1538/// given string, i.e. it will not be null terminated automatically; 1539/// see GetAddrOfConstantCString. Note that whether the result is 1540/// actually a pointer to an LLVM constant depends on 1541/// Feature.WriteableStrings. 1542/// 1543/// The result has pointer to array type. 1544llvm::Constant *CodeGenModule::GetAddrOfConstantString(const std::string &str, 1545 const char *GlobalName) { 1546 bool IsConstant = !Features.WritableStrings; 1547 1548 // Get the default prefix if a name wasn't specified. 1549 if (!GlobalName) 1550 GlobalName = ".str"; 1551 1552 // Don't share any string literals if strings aren't constant. 1553 if (!IsConstant) 1554 return GenerateStringLiteral(str, false, *this, GlobalName); 1555 1556 llvm::StringMapEntry<llvm::Constant *> &Entry = 1557 ConstantStringMap.GetOrCreateValue(&str[0], &str[str.length()]); 1558 1559 if (Entry.getValue()) 1560 return Entry.getValue(); 1561 1562 // Create a global variable for this. 1563 llvm::Constant *C = GenerateStringLiteral(str, true, *this, GlobalName); 1564 Entry.setValue(C); 1565 return C; 1566} 1567 1568/// GetAddrOfConstantCString - Returns a pointer to a character 1569/// array containing the literal and a terminating '\-' 1570/// character. The result has pointer to array type. 1571llvm::Constant *CodeGenModule::GetAddrOfConstantCString(const std::string &str, 1572 const char *GlobalName){ 1573 return GetAddrOfConstantString(str + '\0', GlobalName); 1574} 1575 1576/// EmitObjCPropertyImplementations - Emit information for synthesized 1577/// properties for an implementation. 1578void CodeGenModule::EmitObjCPropertyImplementations(const 1579 ObjCImplementationDecl *D) { 1580 for (ObjCImplementationDecl::propimpl_iterator 1581 i = D->propimpl_begin(), e = D->propimpl_end(); i != e; ++i) { 1582 ObjCPropertyImplDecl *PID = *i; 1583 1584 // Dynamic is just for type-checking. 1585 if (PID->getPropertyImplementation() == ObjCPropertyImplDecl::Synthesize) { 1586 ObjCPropertyDecl *PD = PID->getPropertyDecl(); 1587 1588 // Determine which methods need to be implemented, some may have 1589 // been overridden. Note that ::isSynthesized is not the method 1590 // we want, that just indicates if the decl came from a 1591 // property. What we want to know is if the method is defined in 1592 // this implementation. 1593 if (!D->getInstanceMethod(PD->getGetterName())) 1594 CodeGenFunction(*this).GenerateObjCGetter( 1595 const_cast<ObjCImplementationDecl *>(D), PID); 1596 if (!PD->isReadOnly() && 1597 !D->getInstanceMethod(PD->getSetterName())) 1598 CodeGenFunction(*this).GenerateObjCSetter( 1599 const_cast<ObjCImplementationDecl *>(D), PID); 1600 } 1601 } 1602} 1603 1604/// EmitNamespace - Emit all declarations in a namespace. 1605void CodeGenModule::EmitNamespace(const NamespaceDecl *ND) { 1606 for (RecordDecl::decl_iterator I = ND->decls_begin(), E = ND->decls_end(); 1607 I != E; ++I) 1608 EmitTopLevelDecl(*I); 1609} 1610 1611// EmitLinkageSpec - Emit all declarations in a linkage spec. 1612void CodeGenModule::EmitLinkageSpec(const LinkageSpecDecl *LSD) { 1613 if (LSD->getLanguage() != LinkageSpecDecl::lang_c && 1614 LSD->getLanguage() != LinkageSpecDecl::lang_cxx) { 1615 ErrorUnsupported(LSD, "linkage spec"); 1616 return; 1617 } 1618 1619 for (RecordDecl::decl_iterator I = LSD->decls_begin(), E = LSD->decls_end(); 1620 I != E; ++I) 1621 EmitTopLevelDecl(*I); 1622} 1623 1624/// EmitTopLevelDecl - Emit code for a single top level declaration. 1625void CodeGenModule::EmitTopLevelDecl(Decl *D) { 1626 // If an error has occurred, stop code generation, but continue 1627 // parsing and semantic analysis (to ensure all warnings and errors 1628 // are emitted). 1629 if (Diags.hasErrorOccurred()) 1630 return; 1631 1632 // Ignore dependent declarations. 1633 if (D->getDeclContext() && D->getDeclContext()->isDependentContext()) 1634 return; 1635 1636 switch (D->getKind()) { 1637 case Decl::CXXConversion: 1638 case Decl::CXXMethod: 1639 case Decl::Function: 1640 // Skip function templates 1641 if (cast<FunctionDecl>(D)->getDescribedFunctionTemplate()) 1642 return; 1643 1644 // Fall through 1645 1646 case Decl::Var: 1647 EmitGlobal(GlobalDecl(cast<ValueDecl>(D))); 1648 break; 1649 1650 // C++ Decls 1651 case Decl::Namespace: 1652 EmitNamespace(cast<NamespaceDecl>(D)); 1653 break; 1654 // No code generation needed. 1655 case Decl::Using: 1656 case Decl::ClassTemplate: 1657 case Decl::FunctionTemplate: 1658 break; 1659 case Decl::CXXConstructor: 1660 EmitCXXConstructors(cast<CXXConstructorDecl>(D)); 1661 break; 1662 case Decl::CXXDestructor: 1663 EmitCXXDestructors(cast<CXXDestructorDecl>(D)); 1664 break; 1665 1666 case Decl::StaticAssert: 1667 // Nothing to do. 1668 break; 1669 1670 // Objective-C Decls 1671 1672 // Forward declarations, no (immediate) code generation. 1673 case Decl::ObjCClass: 1674 case Decl::ObjCForwardProtocol: 1675 case Decl::ObjCCategory: 1676 case Decl::ObjCInterface: 1677 break; 1678 1679 case Decl::ObjCProtocol: 1680 Runtime->GenerateProtocol(cast<ObjCProtocolDecl>(D)); 1681 break; 1682 1683 case Decl::ObjCCategoryImpl: 1684 // Categories have properties but don't support synthesize so we 1685 // can ignore them here. 1686 Runtime->GenerateCategory(cast<ObjCCategoryImplDecl>(D)); 1687 break; 1688 1689 case Decl::ObjCImplementation: { 1690 ObjCImplementationDecl *OMD = cast<ObjCImplementationDecl>(D); 1691 EmitObjCPropertyImplementations(OMD); 1692 Runtime->GenerateClass(OMD); 1693 break; 1694 } 1695 case Decl::ObjCMethod: { 1696 ObjCMethodDecl *OMD = cast<ObjCMethodDecl>(D); 1697 // If this is not a prototype, emit the body. 1698 if (OMD->getBody()) 1699 CodeGenFunction(*this).GenerateObjCMethod(OMD); 1700 break; 1701 } 1702 case Decl::ObjCCompatibleAlias: 1703 // compatibility-alias is a directive and has no code gen. 1704 break; 1705 1706 case Decl::LinkageSpec: 1707 EmitLinkageSpec(cast<LinkageSpecDecl>(D)); 1708 break; 1709 1710 case Decl::FileScopeAsm: { 1711 FileScopeAsmDecl *AD = cast<FileScopeAsmDecl>(D); 1712 std::string AsmString(AD->getAsmString()->getStrData(), 1713 AD->getAsmString()->getByteLength()); 1714 1715 const std::string &S = getModule().getModuleInlineAsm(); 1716 if (S.empty()) 1717 getModule().setModuleInlineAsm(AsmString); 1718 else 1719 getModule().setModuleInlineAsm(S + '\n' + AsmString); 1720 break; 1721 } 1722 1723 default: 1724 // Make sure we handled everything we should, every other kind is a 1725 // non-top-level decl. FIXME: Would be nice to have an isTopLevelDeclKind 1726 // function. Need to recode Decl::Kind to do that easily. 1727 assert(isa<TypeDecl>(D) && "Unsupported decl kind"); 1728 } 1729} 1730