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